?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dirs for OSS
[minix.git] / boot / doshead.s
blob86f5621e43788da3eaef0385a72c09a15f813f09
1 ! Doshead.s - DOS & BIOS support for boot.c Author: Kees J. Bot
2 !
3 !
4 ! This file contains the startup and low level support for the secondary
5 ! boot program. It contains functions for disk, tty and keyboard I/O,
6 ! copying memory to arbitrary locations, etc.
7 !
8 ! This runs under MS-DOS as a .COM file. A .COM file is what Minix calls
9 ! a common I&D executable, except that the first 256 bytes contains DOS
10 ! thingies.
11 !
12 .sect .text; .sect .rom; .sect .data; .sect .bss
13
14 K_I386 = 0x0001 ! Call Minix in 386 mode
15 STACK = 16384 ! Number of bytes for the stack
16
17 DS_SELECTOR = 3*8 ! Kernel data selector
18 ES_SELECTOR = 4*8 ! Flat 4 Gb
19 SS_SELECTOR = 5*8 ! Monitor stack
20 CS_SELECTOR = 6*8 ! Kernel code
21 MCS_SELECTOR= 7*8 ! Monitor code
22
23 ESC = 0x1B ! Escape character
24
25 ! Imported variables and functions:
26 .extern _caddr, _daddr, _runsize, _edata, _end ! Runtime environment
27 .extern _k_flags ! Special kernel flags
28 .extern _mem ! Free memory list
29 .extern _vdisk ! Name of the virtual disk
30
31 .sect .text
32
33 .use16 ! Tell 386 assembler we're in 16-bit mode
34
35 .define _PSP
36 _PSP:
37 .space 256 ! Program Segment Prefix
38
39 dosboot:
40 cld ! C compiler wants UP
41 xor ax, ax ! Zero
42 mov di, _edata ! Start of bss is at end of data
43 mov cx, _end ! End of bss (begin of heap)
44 sub cx, di ! Number of bss bytes
45 shr cx, 1 ! Number of words
46 rep stos ! Clear bss
47 cmp sp, _end+STACK
48 jb 0f
49 mov sp, _end+STACK ! "chmem" to 16 kb
50 0:
51
52 ! Are we called with the /U option?
53 movb cl, (_PSP+0x80) ! Argument byte count
54 xorb ch, ch
55 mov bx, _PSP+0x81 ! Argument string
56 0: jcxz notuflag
57 cmpb (bx), 0x20 ! Whitespace?
58 ja 1f
59 inc bx
60 dec cx
61 jmp 0b
62 1: cmp cx, 2 ! '/U' is two bytes
63 jne notuflag
64 cmpb (bx), 0x2F ! '/'?
65 jne notuflag
66 movb al, 1(bx)
67 andb al, ~0x20 ! Ignore case
68 cmpb al, 0x55 ! 'U'?
69 jne notuflag
70 jmp keepumb ! Go grab an UMB
71 notuflag:
72
73 ! Remember the current video mode for restoration on exit.
74 movb ah, 0x0F ! Get current video mode
75 int 0x10
76 andb al, 0x7F ! Mask off bit 7 (no blanking)
77 movb (old_vid_mode), al
78 movb (cur_vid_mode), al
79
80 ! We require at least MS-DOS 3.0.
81 mov ax, 0x3000 ! Get DOS version
82 int 0x21
83 cmpb al, 3 ! DOS 3.0+ ?
84 jae dosok
85 push tellbaddos
86 call _printf
87 jmp quit
88 .sect .rom
89 tellbaddos: .ascii "MS-DOS 3.0 or better required\n\0"
90 .sect .text
91 dosok:
92
93 ! Find out how much "low" memory there is available, where it starts and
94 ! where it ends.
95 mov di, _mem ! di = memory list
96 mov ax, _PSP+0x80 ! From PSP:80 to next PSP is ours
97 mov dx, ds
98 call seg2abs
99 mov (di), ax
100 mov 2(di), dx ! mem[0].base = ds * 16 + 0x80
101 xor ax, ax
102 mov dx, (_PSP+2) ! First in-use segment far above us
103 call seg2abs
104 sub ax, (di)
105 sbb dx, 2(di) ! Minus base gives size
106 mov 4(di), ax
107 mov 6(di), dx ! mem[1].size = free low memory size
108
109 ! Give C code access to the code segment, data segment and the size of this
110 ! process.
111 xor ax, ax
112 mov dx, cs
113 call seg2abs
114 mov (_caddr+0), ax
115 mov (_caddr+2), dx
116 xor ax, ax
117 mov dx, ds
118 call seg2abs
119 mov (_daddr+0), ax
120 mov (_daddr+2), dx
121 mov ax, sp
122 mov dx, ss ! End of stack = end of program
123 call seg2abs
124 sub ax, (_caddr+0)
125 sbb dx, (_caddr+2) ! Minus start of our code
126 mov (_runsize+0), ax
127 mov (_runsize+2), dx ! Is our size
128
129 ! Patch the regular _getprocessor library routine to jump to 'getprocessor',
130 ! that checks if we happen to be in a V8086 straightjacket by returning '86'.
131 cseg movb (_getprocessor+0), 0xE9
132 mov ax, getprocessor
133 sub ax, _getprocessor+3
134 cseg mov (_getprocessor+1), ax
135
136 ! Grab the largest chunk of extended memory available.
137 call _getprocessor
138 cmp ax, 286 ! Only 286s and above have extended memory
139 jb no_ext
140 mov ax, 0x4300 ! XMS driver check
141 int 0x2F
142 cmpb al, 0x80 ! XMS driver exists?
143 je xmsthere
144 get_ext: ! No driver, so can use all ext memory directly
145 call _getprocessor
146 cmp ax, 486 ! Assume 486s were the first to have >64M
147 jb small_ext ! (It helps to be paranoid when using the BIOS)
148 big_ext:
149 mov ax, 0xE801 ! Code for get memory size for >64M
150 int 0x15 ! ax = mem at 1M per 1K, bx = mem at 16M per 64K
151 jnc got_ext
152 small_ext:
153 movb ah, 0x88 ! Code for get extended memory size
154 clc ! Carry will stay clear if call exists
155 int 0x15 ! Returns size (in K) in ax for AT's
156 jc no_ext
157 test ax, ax ! An AT with no extended memory?
158 jz no_ext
159 xor bx, bx ! bx = mem above 16M per 64K = 0
160 got_ext:
161 mov cx, ax ! cx = copy of ext mem at 1M
162 mov 10(di), 0x0010 ! mem[1].base = 0x00100000 (1M)
163 mul (c1024)
164 mov 12(di), ax ! mem[1].size = "ext mem at 1M" * 1024
165 mov 14(di), dx
166 test bx, bx
167 jz no_ext ! No more ext mem above 16M?
168 cmp cx, 15*1024 ! Chunks adjacent? (precisely 15M at 1M?)
169 je adj_ext
170 mov 18(di), 0x0100 ! mem[2].base = 0x01000000 (16M)
171 mov 22(di), bx ! mem[2].size = "ext mem at 16M" * 64K
172 jmp no_ext
173 adj_ext:
174 add 14(di), bx ! Add ext mem above 16M to mem below 16M
175 no_ext:
176 jmp gotxms
177
178 xmsthere:
179 mov ax, 0x4310 ! Get XMS driver address
180 int 0x2F
181 mov (xms_driver+0), bx
182 mov (xms_driver+2), es
183 push ds
184 pop es
185 movb ah, 0x08 ! Query free extended memory
186 xorb bl, bl
187 callf (xms_driver)
188 testb bl, bl
189 jnz xmserr
190 push ax ! ax = size of largest block in kb
191 mul (c1024)
192 mov 12(di), ax
193 mov 14(di), dx ! mem[1].size = ax * 1024
194 pop dx ! dx = size of largest block in kb
195 movb ah, 0x09 ! Allocate XMS block of size dx
196 callf (xms_driver)
197 test ax, ax
198 jz xmserr
199 mov (xms_handle), dx ! Save handle
200 movb ah, 0x0C ! Lock XMS block (handle in dx)
201 callf (xms_driver)
202 test ax, ax
203 jz xmserr
204 mov 8(di), bx
205 mov 10(di), dx ! mem[1].base = Address of locked block
206 gotxms:
207
208 ! If we're running in a DOS box then they're might be an Upper Memory Block
209 ! we can use. Every little bit helps when in real mode.
210 mov ax, 20(di)
211 or ax, 22(di) ! Can we use mem[2]?
212 jnz gotumb
213 mov dx, 0xFFFF ! dx = Maximum size, i.e. gimme all
214 call getumb ! Get UMB, dx = segment, cx = length
215 test cx, cx ! Did we get a block?
216 jz gotumb
217 xor ax, ax ! dx:ax = memory block
218 call seg2abs
219 mov 16(di), ax
220 mov 18(di), dx ! mem[2].base = memory block base
221 mov dx, cx
222 xor ax, ax ! dx:ax = length of memory block
223 call seg2abs
224 mov 20(di), ax
225 mov 22(di), dx ! mem[2].size = memory block length
226 gotumb:
227
228 ! Set up an INT 24 "critical error" handler that returns "fail". This way
229 ! Minix won't suffer from "(A)bort, (R)etry, (I)nfluence with a large hammer?".
230 mov (0x007C), 0x03B0 ! movb al, 0x03 (fail code)
231 movb (0x007E), 0xCF ! iret
232 movb ah, 0x25 ! Set interrupt vector
233 mov dx, 0x007C ! ds:dx = ds:0x007C = interrupt handler
234 int 0x21
235
236 ! Time to switch to a higher level language (not much higher)
237 call _boot
238
239 ! void ..exit(int status)
240 ! Exit the monitor by returning to DOS.
241 .define _exit, __exit, ___exit ! Make various compilers happy
242 _exit:
243 __exit:
244 ___exit:
245 mov dx, (xms_handle)
246 cmp dx, -1 ! Is there an ext mem block in use?
247 je nohandle
248 movb ah, 0x0D ! Unlock extended memory block
249 callf (xms_driver)
250 mov dx, (xms_handle)
251 movb ah, 0x0A ! Free extended memory block
252 callf (xms_driver)
253 nohandle:
254 call restore_video
255 pop ax
256 pop ax ! Return code in al
257 movb ah, 0x4C ! Terminate with return code
258 int 0x21
259
260 quit: ! exit(1)
261 movb al, 1
262 push ax
263 call _exit
264
265 xmserr:
266 xorb bh, bh
267 push bx
268 push tellxmserr
269 call _printf
270 jmp quit
271 .sect .rom
272 tellxmserr: .ascii "Extended memory problem, error 0x%02x\n\0"
273 .sect .text
274
275 ! int getprocessor(void)
276 ! Prefix for the regular _getprocessor call that first checks if we're
277 ! running in a virtual 8086 box.
278 getprocessor:
279 push sp ! Is pushed sp equal to sp?
280 pop ax
281 cmp ax, sp
282 jne gettrueproc ! If not then it's a plain 8086 or 80186
283 .data1 0x0F,0x01,0xE0 ! Use old 286 SMSW instruction to get the MSW
284 testb al, 0x01 ! Protected mode enabled?
285 jz gettrueproc ! If not then a 286 or better in real mode
286 mov ax, 86 ! Forget fancy tricks, say it's an 8086
287 ret
288 gettrueproc: ! Get the true processor type
289 push bp ! _getprocessor prologue that is patched over.
290 mov bp, sp
291 jmp _getprocessor+3
292
293 ! Try to get an Upper Memory Block under MS-DOS 5+. Try to get one up to size
294 ! dx, return segment of UMB found in dx and size in paragraphs in cx.
295 getumb:
296 xor cx, cx ! Initially nothing found
297 mov ax, 0x3000 ! Get DOS version
298 int 0x21
299 cmpb al, 5 ! MS-DOS 5.0 or better?
300 jb retumb
301 mov ax, 0x544D ! Get UMB kept by BOOT /U
302 int 0x15 ! Returns dx = segment, cx = size
303 jc 0f
304 cmp ax, 0x4D54 ! Carry clear and ax byte swapped?
305 je retumb
306 0: mov ax, 0x5802 ! Get UMB link state
307 int 0x21
308 xorb ah, ah
309 push ax ! Save UMB link state
310 mov ax, 0x5803 ! Set UMB link state
311 mov bx, 0x0001 ! Add UMBs to DOS memory chain
312 int 0x21
313 mov ax, 0x5800 ! Get memory allocation strategy
314 int 0x21
315 push ax ! Save allocation strategy
316 mov ax, 0x5801 ! Set memory allocation strategy
317 mov bx, 0x0080 ! First fit, try high then low memory
318 int 0x21
319 movb ah, 0x48 ! Allocate memory
320 mov bx, dx ! Number of paragraphs wanted
321 int 0x21 ! Fails with bx = size of largest
322 jnc 0f ! Succeeds with ax = allocated block
323 test bx, bx ! Is there any?
324 jz no_umb
325 movb ah, 0x48 ! Allocate memory
326 int 0x21
327 jc no_umb ! Did we get some?
328 0: mov dx, ax ! dx = segment
329 mov cx, bx ! cx = size
330 no_umb: mov ax, 0x5801 ! Set memory allocation strategy
331 pop bx ! bx = saved former strategy
332 int 0x21
333 mov ax, 0x5803 ! Set UMB link state
334 pop bx ! bx = saved former link state
335 int 0x21
336 retumb: ret
337
338 ! 'BOOT /U' instructs this program to grab the biggest available UMB and to
339 ! sit on it until the next invocation of BOOT wants it back. These shenanigans
340 ! are necessary because Windows 95 keeps all UMBs to itself unless you get hold
341 ! of them first.
342 umb = 0x80 ! UMB base and size
343 old15 = 0x84 ! Old 15 interrupt vector
344 new15 = 0x88 ! New 15 interrupt handler
345 keepumb:
346 mov ax, 0x544D ! "Keep UMB" handler already present?
347 int 0x15
348 jc 0f
349 cmp ax, 0x4D54
350 je exitumb ! Already present, so quit
351 0:
352 mov si, new15start
353 mov di, new15
354 mov cx, new15end
355 sub cx, si
356 rep movsb ! Copy handler into place
357 add di, 15
358 movb cl, 4
359 shr di, cl ! di = first segment above handler
360 mov cx, cs
361 cmp cx, 0xA000 ! Are we loaded high perchance?
362 jb nothigh
363 werehigh:
364 add cx, di
365 mov (umb+0), cx ! Use my own memory as the UMB to keep
366 mov ax, (_PSP+2) ! Up to the next in-use segment
367 sub ax, dx ! ax = size of my free memory
368 cmp ax, 0x1000 ! At least 64K?
369 jb exitumb ! Don't bother if less
370 mov (umb+2), 0x1000 ! Size of UMB
371 add di, 0x1000 ! Keep my code plus 64K when TSR
372 jmp hook15
373 nothigh:
374 mov dx, 0x1000
375 call getumb ! Grab an UMB of at most 64K
376 cmp cx, 0x1000 ! Did we get 64K?
377 jb exitumb ! Otherwise don't bother
378 mov (umb+0), dx
379 mov (umb+2), cx
380 hook15:
381 mov ax, 0x3515 ! Get interrupt vector
382 int 0x21
383 mov (old15+0), bx
384 mov (old15+2), es ! Old 15 interrupt
385 mov ax, 0x2515 ! Set interrupt vector
386 mov dx, new15 ! ds:dx = new 15 handler
387 int 0x21
388 mov ax, 0x3100 ! Terminate and stay resident
389 mov dx, di ! dx = di = paragraphs we keep
390 int 0x21
391 exitumb:
392 mov ax, 0x4C00 ! exit(0)
393 int 0x21
394
395 new15start: ! New interrupt 15 handler
396 pushf
397 cmp ax, 0x544D ! Is it my call?
398 je my15
399 popf
400 cseg jmpf (old15) ! No, continue with old 15
401 my15: popf
402 push bp
403 mov bp, sp
404 andb 6(bp), ~0x01 ! clear carry, call will succeed
405 xchgb al, ah ! ax = 4D54, also means call works
406 cseg mov dx, (umb+0) ! dx = base of UMB
407 cseg mov cx, (umb+2) ! cx = size of UMB
408 pop bp
409 iret ! return to caller
410 new15end:
411
412 ! u32_t mon2abs(void *ptr)
413 ! Address in monitor data to absolute address.
414 .define _mon2abs
415 _mon2abs:
416 mov bx, sp
417 mov ax, 2(bx) ! ptr
418 mov dx, ds ! Monitor data segment
419 !jmp seg2abs
420
421 seg2abs: ! Translate dx:ax to the 32 bit address dx-ax
422 push cx
423 movb ch, dh
424 movb cl, 4
425 shl dx, cl
426 shrb ch, cl ! ch-dx = dx << 4
427 add ax, dx
428 adcb ch, 0 ! ch-ax = ch-dx + ax
429 movb dl, ch
430 xorb dh, dh ! dx-ax = ch-ax
431 pop cx
432 ret
433
434 abs2seg: ! Translate the 32 bit address dx-ax to dx:ax
435 push cx
436 movb ch, dl
437 mov dx, ax ! ch-dx = dx-ax
438 and ax, 0x000F ! Offset in ax
439 movb cl, 4
440 shr dx, cl
441 shlb ch, cl
442 orb dh, ch ! dx = ch-dx >> 4
443 pop cx
444 ret
445
446 ! void raw_copy(u32_t dstaddr, u32_t srcaddr, u32_t count)
447 ! Copy count bytes from srcaddr to dstaddr. Don't do overlaps.
448 ! Also handles copying words to or from extended memory.
449 .define _raw_copy
450 _raw_copy:
451 push bp
452 mov bp, sp
453 push si
454 push di ! Save C variable registers
455 copy:
456 cmp 14(bp), 0
457 jnz bigcopy
458 mov cx, 12(bp)
459 jcxz copydone ! Count is zero, end copy
460 cmp cx, 0xFFF0
461 jb smallcopy
462 bigcopy:mov cx, 0xFFF0 ! Don't copy more than about 64K at once
463 smallcopy:
464 push cx ! Save copying count
465 mov ax, 4(bp)
466 mov dx, 6(bp)
467 cmp dx, 0x0010 ! Copy to extended memory?
468 jae ext_copy
469 cmp 10(bp), 0x0010 ! Copy from extended memory?
470 jae ext_copy
471 call abs2seg
472 mov di, ax
473 mov es, dx ! es:di = dstaddr
474 mov ax, 8(bp)
475 mov dx, 10(bp)
476 call abs2seg
477 mov si, ax
478 mov ds, dx ! ds:si = srcaddr
479 shr cx, 1 ! Words to move
480 rep movs ! Do the word copy
481 adc cx, cx ! One more byte?
482 rep movsb ! Do the byte copy
483 mov ax, ss ! Restore ds and es from the remaining ss
484 mov ds, ax
485 mov es, ax
486 jmp copyadjust
487 ext_copy:
488 mov (x_dst_desc+2), ax
489 movb (x_dst_desc+4), dl ! Set base of destination segment
490 mov ax, 8(bp)
491 mov dx, 10(bp)
492 mov (x_src_desc+2), ax
493 movb (x_src_desc+4), dl ! Set base of source segment
494 mov si, x_gdt ! es:si = global descriptor table
495 shr cx, 1 ! Words to move
496 movb ah, 0x87 ! Code for extended memory move
497 int 0x15
498 copyadjust:
499 pop cx ! Restore count
500 add 4(bp), cx
501 adc 6(bp), 0 ! srcaddr += copycount
502 add 8(bp), cx
503 adc 10(bp), 0 ! dstaddr += copycount
504 sub 12(bp), cx
505 sbb 14(bp), 0 ! count -= copycount
506 jmp copy ! and repeat
507 copydone:
508 pop di
509 pop si ! Restore C variable registers
510 pop bp
511 ret
512
513 ! u16_t get_word(u32_t addr);
514 ! void put_word(u32_t addr, u16_t word);
515 ! Read or write a 16 bits word at an arbitrary location.
516 .define _get_word, _put_word
517 _get_word:
518 mov bx, sp
519 call gp_getaddr
520 mov ax, (bx) ! Word to get from addr
521 jmp gp_ret
522 _put_word:
523 mov bx, sp
524 push 6(bx) ! Word to store at addr
525 call gp_getaddr
526 pop (bx) ! Store the word
527 jmp gp_ret
528 gp_getaddr:
529 mov ax, 2(bx)
530 mov dx, 4(bx)
531 call abs2seg
532 mov bx, ax
533 mov ds, dx ! ds:bx = addr
534 ret
535 gp_ret:
536 push es
537 pop ds ! Restore ds
538 ret
539
540 ! void relocate(void);
541 ! After the program has copied itself to a safer place, it needs to change
542 ! the segment registers. Caddr has already been set to the new location.
543 .define _relocate
544 _relocate:
545 pop bx ! Return address
546 mov ax, (_caddr+0)
547 mov dx, (_caddr+2)
548 call abs2seg
549 mov cx, dx ! cx = new code segment
550 mov ax, cs ! Old code segment
551 sub ax, cx ! ax = -(new - old) = -Moving offset
552 mov dx, ds
553 sub dx, ax
554 mov ds, dx ! ds += (new - old)
555 mov es, dx
556 mov ss, dx
557 xor ax, ax
558 call seg2abs
559 mov (_daddr+0), ax
560 mov (_daddr+2), dx ! New data address
561 push cx ! New text segment
562 push bx ! Return offset of this function
563 retf ! Relocate
564
565 ! void *brk(void *addr)
566 ! void *sbrk(size_t incr)
567 ! Cannot fail implementations of brk(2) and sbrk(3), so we can use
568 ! malloc(3). They reboot on stack collision instead of returning -1.
569 .sect .data
570 .align 2
571 break: .data2 _end ! A fake heap pointer
572 .sect .text
573 .define _brk, __brk, _sbrk, __sbrk
574 _brk:
575 __brk: ! __brk is for the standard C compiler
576 xor ax, ax
577 jmp sbrk ! break= 0; return sbrk(addr);
578 _sbrk:
579 __sbrk:
580 mov ax, (break) ! ax= current break
581 sbrk: push ax ! save it as future return value
582 mov bx, sp ! Stack is now: (retval, retaddr, incr, ...)
583 add ax, 4(bx) ! ax= break + increment
584 mov (break), ax ! Set new break
585 lea dx, -1024(bx) ! sp minus a bit of breathing space
586 cmp dx, ax ! Compare with the new break
587 jb heaperr ! Suffocating noises
588 pop ax ! Return old break (0 for brk)
589 ret
590 heaperr:push nomem
591 call _printf
592 call quit
593 .sect .rom
594 nomem: .ascii "\nOut of memory\n\0"
595 .sect .text
596
597 ! int dev_open(void);
598 ! Open file 'vdisk' to use as the Minix virtual disk. Store handle in
599 ! vfd. Returns 0 for success, otherwise the DOS error code.
600 .define _dev_open
601 _dev_open:
602 call _dev_close ! If already open then first close
603 mov dx, (_vdisk) ! ds:dx = Address of file name
604 mov ax, 0x3D22 ! Open file read-write & deny write
605 int 0x21
606 jnc opok ! Open succeeded?
607 cmp ax, 5 ! Open failed, "access denied"?
608 jne opbad
609 mov ax, 0x3D40 ! Open file read-only
610 int 0x21
611 jc opbad
612 opok: mov (vfd), ax ! File handle to open file
613 xor ax, ax ! Zero for success
614 opbad: ret
615
616 ! int dev_close(void);
617 ! Close the dos virtual disk.
618 .define _dev_close
619 _dev_close:
620 mov bx, -1
621 cmp (vfd), bx ! Already closed?
622 je 1f
623 movb ah, 0x3E ! Close file
624 xchg bx, (vfd) ! bx = vfd; vfd = -1;
625 int 0x21
626 jc 0f
627 1: xor ax, ax
628 0: ret
629
630 ! int dev_boundary(u32_t sector);
631 ! Returns false; files have no visible boundaries.
632 .define _dev_boundary
633 _dev_boundary:
634 xor ax, ax
635 ret
636
637 ! int readsectors(u32_t bufaddr, u32_t sector, u8_t count)
638 ! int writesectors(u32_t bufaddr, u32_t sector, u8_t count)
639 ! Read/write several sectors from/to the Minix virtual disk. Count
640 ! must fit in a byte. The external variable vfd is the file handle.
641 ! Returns 0 for success, otherwise the DOS error code.
642 !
643 .define _readsectors, _writesectors
644 _writesectors:
645 push bp
646 mov bp, sp
647 movb 13(bp), 0x40 ! Code for a file write
648 jmp rwsec
649 _readsectors:
650 push bp
651 mov bp, sp
652 movb 13(bp), 0x3F ! Code for a file read
653 rwsec:
654 cmp (vfd), -1 ! Currently closed?
655 jne 0f
656 call _dev_open ! Open file if needed
657 test ax, ax
658 jnz rwerr
659 0: mov dx, 8(bp)
660 mov bx, 10(bp) ! bx-dx = Sector number
661 mov cx, 9
662 mul512: shl dx, 1
663 rcl bx, 1 ! bx-dx *= 512
664 loop mul512
665 mov cx, bx ! cx-dx = Byte position in file
666 mov bx, (vfd) ! bx = File handle
667 mov ax, 0x4200 ! Lseek absolute
668 int 0x21
669 jb rwerr
670 mov bx, (vfd) ! bx = File handle
671 mov ax, 4(bp)
672 mov dx, 6(bp) ! dx-ax = Address to transfer data to/from
673 call abs2seg
674 mov ds, dx
675 mov dx, ax ! ds:dx = Address to transfer data to/from
676 xorb cl, cl
677 movb ch, 12(bp) ! ch = Number of sectors to transfer
678 shl cx, 1 ! cx = Number of bytes to transfer
679 push cx ! Save count
680 movb ah, 13(bp) ! Read or write
681 int 0x21
682 pop cx ! Restore count
683 push es
684 pop ds ! Restore ds
685 jb rwerr
686 cmp ax, cx ! All bytes transferred?
687 je rwall
688 mov ax, 0x05 ! The DOS code for "I/O error", but different
689 jmp rwerr
690 rwall: call wheel ! Display tricks
691 xor ax, ax
692 rwerr: pop bp
693 ret
694
695 ! int getch(void);
696 ! Read a character from the keyboard, and check for an expired timer.
697 ! A carriage return is changed into a linefeed for UNIX compatibility.
698 .define _getch
699 _getch:
700 xor ax, ax
701 xchg ax, (unchar) ! Ungotten character?
702 test ax, ax
703 jnz gotch
704 getch: hlt ! Play dead until interrupted (see pause())
705 movb ah, 0x01 ! Keyboard status
706 int 0x16
707 jnz press ! Keypress?
708 call _expired ! Timer expired?
709 test ax, ax
710 jz getch
711 mov ax, ESC ! Return ESC
712 ret
713 press:
714 xorb ah, ah ! Read character from keyboard
715 int 0x16
716 cmpb al, 0x0D ! Carriage return?
717 jnz nocr
718 movb al, 0x0A ! Change to linefeed
719 nocr: cmpb al, ESC ! Escape typed?
720 jne noesc
721 inc (escape) ! Set flag
722 noesc: xorb ah, ah ! ax = al
723 gotch: ret
724
725 ! int ungetch(void);
726 ! Return a character to undo a getch().
727 .define _ungetch
728 _ungetch:
729 mov bx, sp
730 mov ax, 2(bx)
731 mov (unchar), ax
732 ret
733
734 ! int escape(void);
735 ! True if ESC has been typed.
736 .define _escape
737 _escape:
738 movb ah, 0x01 ! Keyboard status
739 int 0x16
740 jz escflg ! Keypress?
741 cmpb al, ESC ! Escape typed?
742 jne escflg
743 xorb ah, ah ! Discard the escape
744 int 0x16
745 inc (escape) ! Set flag
746 escflg: xor ax, ax
747 xchg ax, (escape) ! Escape typed flag
748 ret
749
750 ! int putch(int c);
751 ! Write a character in teletype mode. The putk synonym is
752 ! for the kernel printf function that uses it.
753 ! Newlines are automatically preceded by a carriage return.
754 !
755 .define _putch, _putk
756 _putch:
757 _putk: mov bx, sp
758 movb al, 2(bx) ! al = character to be printed
759 testb al, al ! Kernel printf adds a null char to flush queue
760 jz nulch
761 cmpb al, 0x0A ! al = newline?
762 jnz putc
763 movb al, 0x20 ! Erase wheel and do a carriage return
764 call plotc ! plotc(' ');
765 nodirt: movb al, 0x0D
766 call putc ! putc('\r')
767 movb al, 0x0A ! Restore the '\n' and print it
768 putc: movb ah, 0x0E ! Print character in teletype mode
769 mov bx, 0x0001 ! Page 0, foreground color
770 int 0x10 ! Call BIOS VIDEO_IO
771 nulch: ret
772
773 ! |/-\|/-\|/-\|/-\|/-\ (playtime)
774 wheel: mov bx, (gp)
775 movb al, (bx)
776 inc bx ! al = *gp++;
777 cmp bx, glyphs+4
778 jne 0f
779 mov bx, glyphs
780 0: mov (gp), bx ! gp= gp == glyphs + 4 ? glyphs : gp;
781 !jmp plotc
782 plotc: movb ah, 0x0A ! 0x0A = write character at cursor
783 mov bx, 0x0001 ! Page 0, foreground color
784 mov cx, 0x0001 ! Just one character
785 int 0x10
786 ret
787 .sect .data
788 .align 2
789 gp: .data2 glyphs
790 glyphs: .ascii "|/-\\"
791 .sect .text
792
793 ! void pause(void);
794 ! Wait for an interrupt using the HLT instruction. This either saves
795 ! power, or tells an x86 emulator that nothing is happening right now.
796 .define _pause
797 _pause:
798 hlt
799 ret
800
801 ! void set_mode(unsigned mode);
802 ! void clear_screen(void);
803 ! Set video mode / clear the screen.
804 .define _set_mode, _clear_screen
805 _set_mode:
806 mov bx, sp
807 mov ax, 2(bx) ! Video mode
808 cmp ax, (cur_vid_mode)
809 je modeok ! Mode already as requested?
810 mov (cur_vid_mode), ax
811 _clear_screen:
812 mov ax, (cur_vid_mode)
813 andb ah, 0x7F ! Test bits 8-14, clear bit 15 (8x8 flag)
814 jnz xvesa ! VESA extended mode?
815 int 0x10 ! Reset video (ah = 0)
816 jmp mdset
817 xvesa: mov bx, ax ! bx = extended mode
818 mov ax, 0x4F02 ! Reset video
819 int 0x10
820 mdset: testb (cur_vid_mode+1), 0x80
821 jz setcur ! 8x8 font requested?
822 mov ax, 0x1112 ! Load ROM 8 by 8 double-dot patterns
823 xorb bl, bl ! Load block 0
824 int 0x10
825 setcur: xor dx, dx ! dl = column = 0, dh = row = 0
826 xorb bh, bh ! Page 0
827 movb ah, 0x02 ! Set cursor position
828 int 0x10
829 modeok: ret
830
831 restore_video: ! To restore the video mode on exit
832 movb al, 0x20
833 call plotc ! Erase wheel
834 push (old_vid_mode)
835 call _set_mode
836 pop ax
837 ret
838
839 ! u32_t get_tick(void);
840 ! Return the current value of the clock tick counter. This counter
841 ! increments 18.2 times per second. Poll it to do delays. Does not
842 ! work on the original PC, but works on the PC/XT.
843 .define _get_tick
844 _get_tick:
845 xorb ah, ah ! Code for get tick count
846 int 0x1A
847 mov ax, dx
848 mov dx, cx ! dx:ax = cx:dx = tick count
849 ret
850
851
852 ! Functions used to obtain info about the hardware. Boot uses this information
853 ! itself, but will also pass them on to a pure 386 kernel, because one can't
854 ! make BIOS calls from protected mode. The video type could probably be
855 ! determined by the kernel too by looking at the hardware, but there is a small
856 ! chance on errors that the monitor allows you to correct by setting variables.
857
858 .define _get_bus ! returns type of system bus
859 .define _get_video ! returns type of display
860
861 ! u16_t get_bus(void)
862 ! Return type of system bus, in order: XT, AT, MCA.
863 _get_bus:
864 call gettrueproc
865 xor dx, dx ! Assume XT
866 cmp ax, 286 ! An AT has at least a 286
867 jb got_bus
868 inc dx ! Assume AT
869 movb ah, 0xC0 ! Code for get configuration
870 int 0x15
871 jc got_bus ! Carry clear and ah = 00 if supported
872 testb ah, ah
873 jne got_bus
874 eseg movb al, 5(bx) ! Load feature byte #1
875 inc dx ! Assume MCA
876 testb al, 0x02 ! Test bit 1 - "bus is Micro Channel"
877 jnz got_bus
878 dec dx ! Assume AT
879 testb al, 0x40 ! Test bit 6 - "2nd 8259 installed"
880 jnz got_bus
881 dec dx ! It is an XT
882 got_bus:
883 push ds
884 pop es ! Restore es
885 mov ax, dx ! Return bus code
886 mov (bus), ax ! Keep bus code, A20 handler likes to know
887 ret
888
889 ! u16_t get_video(void)
890 ! Return type of display, in order: MDA, CGA, mono EGA, color EGA,
891 ! mono VGA, color VGA.
892 _get_video:
893 mov ax, 0x1A00 ! Function 1A returns display code
894 int 0x10 ! al = 1A if supported
895 cmpb al, 0x1A
896 jnz no_dc ! No display code function supported
897
898 mov ax, 2
899 cmpb bl, 5 ! Is it a monochrome EGA?
900 jz got_video
901 inc ax
902 cmpb bl, 4 ! Is it a color EGA?
903 jz got_video
904 inc ax
905 cmpb bl, 7 ! Is it a monochrome VGA?
906 jz got_video
907 inc ax
908 cmpb bl, 8 ! Is it a color VGA?
909 jz got_video
910
911 no_dc: movb ah, 0x12 ! Get information about the EGA
912 movb bl, 0x10
913 int 0x10
914 cmpb bl, 0x10 ! Did it come back as 0x10? (No EGA)
915 jz no_ega
916
917 mov ax, 2
918 cmpb bh, 1 ! Is it monochrome?
919 jz got_video
920 inc ax
921 jmp got_video
922
923 no_ega: int 0x11 ! Get bit pattern for equipment
924 and ax, 0x30 ! Isolate color/mono field
925 sub ax, 0x30
926 jz got_video ! Is it an MDA?
927 mov ax, 1 ! No it's CGA
928
929 got_video:
930 ret
931
932
933 ! Function to leave the boot monitor and run Minix.
934 .define _minix
935
936 ! void minix(u32_t koff, u32_t kcs, u32_t kds,
937 ! char *bootparams, size_t paramsize, u32_t aout);
938 _minix:
939 push bp
940 mov bp, sp ! Pointer to arguments
941
942 mov dx, 0x03F2 ! Floppy motor drive control bits
943 movb al, 0x0C ! Bits 4-7 for floppy 0-3 are off
944 outb dx ! Kill the motors
945 push ds
946 xor ax, ax ! Vector & BIOS data segments
947 mov ds, ax
948 andb (0x043F), 0xF0 ! Clear diskette motor status bits of BIOS
949 pop ds
950 cli ! No more interruptions
951
952 test (_k_flags), K_I386 ! Minix-386?
953 jnz minix386
954
955 ! Call Minix in real mode.
956 minix86:
957 push 22(bp) ! Address of a.out headers
958 push 20(bp)
959
960 push 18(bp) ! # bytes of boot parameters
961 push 16(bp) ! Address of boot parameters
962
963 mov dx, cs ! Monitor far return address
964 mov ax, ret86
965 cmp (_mem+14), 0 ! Any extended memory? (mem[1].size > 0 ?)
966 jnz 0f
967 xor dx, dx ! If no ext mem then monitor not preserved
968 xor ax, ax
969 0: push dx ! Push monitor far return address or zero
970 push ax
971
972 mov ax, 8(bp)
973 mov dx, 10(bp)
974 call abs2seg
975 push dx ! Kernel code segment
976 push 4(bp) ! Kernel code offset
977 mov ax, 12(bp)
978 mov dx, 14(bp)
979 call abs2seg
980 mov ds, dx ! Kernel data segment
981 mov es, dx ! Set es to kernel data too
982 retf ! Make a far call to the kernel
983
984 ! Call 386 Minix in 386 mode.
985 minix386:
986 cseg mov (cs_real-2), cs ! Patch CS and DS into the instructions that
987 cseg mov (ds_real-2), ds ! reload them when switching back to real mode
988 mov eax, cr0
989 orb al, 0x01 ! Set PE (protection enable) bit
990 o32 mov (msw), eax ! Save as protected mode machine status word
991
992 mov dx, ds ! Monitor ds
993 mov ax, p_gdt ! dx:ax = Global descriptor table
994 call seg2abs
995 mov (p_gdt_desc+2), ax
996 movb (p_gdt_desc+4), dl ! Set base of global descriptor table
997
998 mov ax, 12(bp)
999 mov dx, 14(bp) ! Kernel ds (absolute address)
1000 mov (p_ds_desc+2), ax
1001 movb (p_ds_desc+4), dl ! Set base of kernel data segment
1002
1003 mov dx, ss ! Monitor ss
1004 xor ax, ax ! dx:ax = Monitor stack segment
1005 call seg2abs ! Minix starts with the stack of the monitor
1006 mov (p_ss_desc+2), ax
1007 movb (p_ss_desc+4), dl
1008
1009 mov ax, 8(bp)
1010 mov dx, 10(bp) ! Kernel cs (absolute address)
1011 mov (p_cs_desc+2), ax
1012 movb (p_cs_desc+4), dl
1013
1014 mov dx, cs ! Monitor cs
1015 xor ax, ax ! dx:ax = Monitor code segment
1016 call seg2abs
1017 mov (p_mcs_desc+2), ax
1018 movb (p_mcs_desc+4), dl
1019
1020 push MCS_SELECTOR
1021 push int86 ! Far address to INT86 support
1022
1023 o32 push 20(bp) ! Address of a.out headers
1024
1025 push 0
1026 push 18(bp) ! 32 bit size of parameters on stack
1027 push 0
1028 push 16(bp) ! 32 bit address of parameters (ss relative)
1029
1030 push MCS_SELECTOR
1031 push ret386 ! Monitor far return address
1032
1033 push 0
1034 push CS_SELECTOR
1035 push 6(bp)
1036 push 4(bp) ! 32 bit far address to kernel entry point
1037
1038 call real2prot ! Switch to protected mode
1039 mov ax, DS_SELECTOR
1040 mov ds, ax ! Kernel data
1041 mov ax, ES_SELECTOR
1042 mov es, ax ! Flat 4 Gb
1043 o32 retf ! Make a far call to the kernel
1044
1045 ! Minix-86 returns here on a halt or reboot.
1046 ret86:
1047 mov 8(bp), ax
1048 mov 10(bp), dx ! Return value
1049 jmp return
1050
1051 ! Minix-386 returns here on a halt or reboot.
1052 ret386:
1053 o32 mov 8(bp), eax ! Return value
1054 call prot2real ! Switch to real mode
1055
1056 return:
1057 mov sp, bp ! Pop parameters
1058 sti ! Can take interrupts again
1059
1060 call _get_video ! MDA, CGA, EGA, ...
1061 movb dh, 24 ! dh = row 24
1062 cmp ax, 2 ! At least EGA?
1063 jb is25 ! Otherwise 25 rows
1064 push ds
1065 xor ax, ax ! Vector & BIOS data segments
1066 mov ds, ax
1067 movb dh, (0x0484) ! Number of rows on display minus one
1068 pop ds
1069 is25:
1070 xorb dl, dl ! dl = column 0
1071 xorb bh, bh ! Page 0
1072 movb ah, 0x02 ! Set cursor position
1073 int 0x10
1074
1075 xorb ah, ah ! Whack the disk system, Minix may have messed
1076 movb dl, 0x80 ! it up
1077 int 0x13
1078
1079 call gettrueproc
1080 cmp ax, 286
1081 jb noclock
1082 xorb al, al
1083 tryclk: decb al
1084 jz noclock
1085 movb ah, 0x02 ! Get real-time clock time (from CMOS clock)
1086 int 0x1A
1087 jc tryclk ! Carry set, not running or being updated
1088 movb al, ch ! ch = hour in BCD
1089 call bcd ! al = (al >> 4) * 10 + (al & 0x0F)
1090 mulb (c60) ! 60 minutes in an hour
1091 mov bx, ax ! bx = hour * 60
1092 movb al, cl ! cl = minutes in BCD
1093 call bcd
1094 add bx, ax ! bx = hour * 60 + minutes
1095 movb al, dh ! dh = seconds in BCD
1096 call bcd
1097 xchg ax, bx ! ax = hour * 60 + minutes, bx = seconds
1098 mul (c60) ! dx-ax = (hour * 60 + minutes) * 60
1099 add bx, ax
1100 adc dx, 0 ! dx-bx = seconds since midnight
1101 mov ax, dx
1102 mul (c19663)
1103 xchg ax, bx
1104 mul (c19663)
1105 add dx, bx ! dx-ax = dx-bx * (0x1800B0 / (2*2*2*2*5))
1106 mov cx, ax ! (0x1800B0 = ticks per day of BIOS clock)
1107 mov ax, dx
1108 xor dx, dx
1109 div (c1080)
1110 xchg ax, cx
1111 div (c1080) ! cx-ax = dx-ax / (24*60*60 / (2*2*2*2*5))
1112 mov dx, ax ! cx-dx = ticks since midnight
1113 movb ah, 0x01 ! Set system time
1114 int 0x1A
1115 noclock:
1116
1117 mov ax, 8(bp)
1118 mov dx, 10(bp) ! dx-ax = return value from the kernel
1119 pop bp
1120 ret ! Return to monitor as if nothing much happened
1121
1122 ! Transform BCD number in al to a regular value in ax.
1123 bcd: movb ah, al
1124 shrb ah, 4
1125 andb al, 0x0F
1126 aad ! ax = (al >> 4) * 10 + (al & 0x0F)
1127 ret
1128
1129 ! Support function for Minix-386 to make an 8086 interrupt call.
1130 int86:
1131 mov bp, sp
1132 call prot2real
1133
1134 o32 xor eax, eax
1135 mov es, ax ! Vector & BIOS data segments
1136 o32 eseg mov (0x046C), eax ! Clear BIOS clock tick counter
1137
1138 sti ! Enable interrupts
1139
1140 movb al, 0xCD ! INT instruction
1141 movb ah, 8(bp) ! Interrupt number?
1142 testb ah, ah
1143 jnz 0f ! Nonzero if INT, otherwise far call
1144 push cs
1145 push intret+2 ! Far return address
1146 o32 push 12(bp) ! Far driver address
1147 mov ax, 0x90CB ! RETF; NOP
1148 0: cseg mov (intret), ax ! Patch 'INT n' or 'RETF; NOP' into code
1149
1150 mov ds, 16(bp) ! Load parameters
1151 mov es, 18(bp)
1152 o32 mov eax, 20(bp)
1153 o32 mov ebx, 24(bp)
1154 o32 mov ecx, 28(bp)
1155 o32 mov edx, 32(bp)
1156 o32 mov esi, 36(bp)
1157 o32 mov edi, 40(bp)
1158 o32 mov ebp, 44(bp)
1159
1160 intret: int 0xFF ! Do the interrupt or far call
1161
1162 o32 push ebp ! Save results
1163 o32 pushf
1164 mov bp, sp
1165 o32 pop 8+8(bp) ! eflags
1166 mov 8+16(bp), ds
1167 mov 8+18(bp), es
1168 o32 mov 8+20(bp), eax
1169 o32 mov 8+24(bp), ebx
1170 o32 mov 8+28(bp), ecx
1171 o32 mov 8+32(bp), edx
1172 o32 mov 8+36(bp), esi
1173 o32 mov 8+40(bp), edi
1174 o32 pop 8+44(bp) ! ebp
1175
1176 cli ! Disable interrupts
1177
1178 xor ax, ax
1179 mov ds, ax ! Vector & BIOS data segments
1180 o32 mov cx, (0x046C) ! Collect lost clock ticks in ecx
1181
1182 mov ax, ss
1183 mov ds, ax ! Restore monitor ds
1184 call real2prot
1185 mov ax, DS_SELECTOR ! Kernel data
1186 mov ds, ax
1187 o32 retf ! Return to the kernel
1188
1189 ! Switch from real to protected mode.
1190 real2prot:
1191 movb ah, 0x02 ! Code for A20 enable
1192 call gate_A20
1193
1194 lgdt (p_gdt_desc) ! Global descriptor table
1195 o32 mov eax, (pdbr) ! Load page directory base register
1196 mov cr3, eax
1197 mov eax, cr0
1198 o32 xchg eax, (msw) ! Exchange real mode msw for protected mode msw
1199 mov cr0, eax
1200 jmpf MCS_SELECTOR:cs_prot ! Set code segment selector
1201 cs_prot:
1202 mov ax, SS_SELECTOR ! Set data selectors
1203 mov ds, ax
1204 mov es, ax
1205 mov ss, ax
1206 ret
1207
1208 ! Switch from protected to real mode.
1209 prot2real:
1210 lidt (p_idt_desc) ! Real mode interrupt vectors
1211 mov eax, cr3
1212 o32 mov (pdbr), eax ! Save page directory base register
1213 mov eax, cr0
1214 o32 xchg eax, (msw) ! Exchange protected mode msw for real mode msw
1215 mov cr0, eax
1216 jmpf 0xDEAD:cs_real ! Reload cs register
1217 cs_real:
1218 mov ax, 0xBEEF
1219 ds_real:
1220 mov ds, ax ! Reload data segment registers
1221 mov es, ax
1222 mov ss, ax
1223
1224 xorb ah, ah ! Code for A20 disable
1225 !jmp gate_A20
1226
1227 ! Enable (ah = 0x02) or disable (ah = 0x00) the A20 address line.
1228 gate_A20:
1229 cmp (bus), 2 ! PS/2 bus?
1230 je gate_PS_A20
1231 call kb_wait
1232 movb al, 0xD1 ! Tell keyboard that a command is coming
1233 outb 0x64
1234 call kb_wait
1235 movb al, 0xDD ! 0xDD = A20 disable code if ah = 0x00
1236 orb al, ah ! 0xDF = A20 enable code if ah = 0x02
1237 outb 0x60
1238 call kb_wait
1239 movb al, 0xFF ! Pulse output port
1240 outb 0x64
1241 call kb_wait ! Wait for the A20 line to settle down
1242 ret
1243 kb_wait:
1244 inb 0x64
1245 testb al, 0x02 ! Keyboard input buffer full?
1246 jnz kb_wait ! If so, wait
1247 ret
1248
1249 gate_PS_A20: ! The PS/2 can twiddle A20 using port A
1250 inb 0x92 ! Read port A
1251 andb al, 0xFD
1252 orb al, ah ! Set A20 bit to the required state
1253 outb 0x92 ! Write port A
1254 jmp .+2 ! Small delay
1255 A20ok: inb 0x92 ! Check port A
1256 andb al, 0x02
1257 cmpb al, ah ! A20 line settled down to the new state?
1258 jne A20ok ! If not then wait
1259 ret
1260
1261 ! void int15(bios_env_t *ep)
1262 ! Do an "INT 15" call, primarily for APM (Power Management).
1263 .define _int15
1264 _int15:
1265 push si ! Save callee-save register si
1266 mov si, sp
1267 mov si, 4(si) ! ep
1268 mov ax, (si) ! ep->ax
1269 mov bx, 2(si) ! ep->bx
1270 mov cx, 4(si) ! ep->cx
1271 int 0x15 ! INT 0x15 BIOS call
1272 pushf ! Save flags
1273 mov (si), ax ! ep->ax
1274 mov 2(si), bx ! ep->bx
1275 mov 4(si), cx ! ep->cx
1276 pop 6(si) ! ep->flags
1277 pop si ! Restore
1278 ret
1279
1280 .sect .rom
1281 .align 4
1282 c60: .data2 60 ! Constants for MUL and DIV
1283 c1024: .data2 1024
1284 c1080: .data2 1080
1285 c19663: .data2 19663
1286
1287 .sect .data
1288 .align 4
1289
1290 ! Global descriptor tables.
1291 UNSET = 0 ! Must be computed
1292
1293 ! For "Extended Memory Block Move".
1294 x_gdt:
1295 x_null_desc:
1296 ! Null descriptor
1297 .data2 0x0000, 0x0000
1298 .data1 0x00, 0x00, 0x00, 0x00
1299 x_gdt_desc:
1300 ! Descriptor for this descriptor table
1301 .data2 6*8-1, UNSET
1302 .data1 UNSET, 0x00, 0x00, 0x00
1303 x_src_desc:
1304 ! Source segment descriptor
1305 .data2 0xFFFF, UNSET
1306 .data1 UNSET, 0x92, 0x00, 0x00
1307 x_dst_desc:
1308 ! Destination segment descriptor
1309 .data2 0xFFFF, UNSET
1310 .data1 UNSET, 0x92, 0x00, 0x00
1311 x_bios_desc:
1312 ! BIOS segment descriptor (scratch for int 0x15)
1313 .data2 UNSET, UNSET
1314 .data1 UNSET, UNSET, UNSET, UNSET
1315 x_ss_desc:
1316 ! BIOS stack segment descriptor (scratch for int 0x15)
1317 .data2 UNSET, UNSET
1318 .data1 UNSET, UNSET, UNSET, UNSET
1319
1320 ! Protected mode descriptor table.
1321 p_gdt:
1322 p_null_desc:
1323 ! Null descriptor
1324 .data2 0x0000, 0x0000
1325 .data1 0x00, 0x00, 0x00, 0x00
1326 p_gdt_desc:
1327 ! Descriptor for this descriptor table
1328 .data2 8*8-1, UNSET
1329 .data1 UNSET, 0x00, 0x00, 0x00
1330 p_idt_desc:
1331 ! Real mode interrupt descriptor table descriptor
1332 .data2 0x03FF, 0x0000
1333 .data1 0x00, 0x00, 0x00, 0x00
1334 p_ds_desc:
1335 ! Kernel data segment descriptor (4Gb flat)
1336 .data2 0xFFFF, UNSET
1337 .data1 UNSET, 0x92, 0xCF, 0x00
1338 p_es_desc:
1339 ! Physical memory descriptor (4Gb flat)
1340 .data2 0xFFFF, 0x0000
1341 .data1 0x00, 0x92, 0xCF, 0x00
1342 p_ss_desc:
1343 ! Monitor data segment descriptor (64Kb flat)
1344 .data2 0xFFFF, UNSET
1345 .data1 UNSET, 0x92, 0x00, 0x00
1346 p_cs_desc:
1347 ! Kernel code segment descriptor (4Gb flat)
1348 .data2 0xFFFF, UNSET
1349 .data1 UNSET, 0x9A, 0xCF, 0x00
1350 p_mcs_desc:
1351 ! Monitor code segment descriptor (64 kb flat) (unused)
1352 .data2 0xFFFF, UNSET
1353 .data1 UNSET, 0x9A, 0x00, 0x00
1354
1355 xms_handle: .data2 -1 ! Handle of allocated XMS block
1356 vfd: .data2 -1 ! Virtual disk file handle
1357
1358 .sect .bss
1359 .comm xms_driver, 4 ! Vector to XMS driver
1360 .comm old_vid_mode, 2 ! Video mode at startup
1361 .comm cur_vid_mode, 2 ! Current video mode
1362 .comm msw, 4 ! Saved machine status word (cr0)
1363 .comm pdbr, 4 ! Saved page directory base register (cr3)
1364 .comm escape, 2 ! Escape typed?
1365 .comm bus, 2 ! Saved return value of _get_bus
1366 .comm unchar, 2 ! Char returned by ungetch(c)
1367
1368 !
1369 ! $PchId: doshead.ack.s,v 1.7 2002/02/27 19:37:52 philip Exp $
MINIX 3 (repo.or.cz mirror)