URL
https://opencores.org/ocsvn/zet86/zet86/trunk
Subversion Repositories zet86
Compare Revisions
- This comparison shows the changes necessary to convert path
/zet86/trunk/soc/bios
- from Rev 49 to Rev 52
- ↔ Reverse comparison
Rev 49 → Rev 52
/biossums.c
1,5 → 1,5
/* |
* $Id: biossums.c,v 1.7 2009-02-06 03:48:27 zeus Exp $ |
* $Id: biossums.c,v 1.4 2007/05/28 08:09:13 vruppert Exp $ |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
/makesym.perl
1,6 → 1,6
#!/usr/bin/perl |
# |
# $Id: makesym.perl,v 1.7 2009-02-06 03:48:27 zeus Exp $ |
# $Id: makesym.perl,v 1.2 2008/01/26 09:15:27 sshwarts Exp $ |
# |
# Read output file from as86 (e.g. rombios.txt) and write out a symbol |
# table suitable for the Bochs debugger. |
/rombios.c
421,6 → 421,16
dec bx |
ret |
|
lincl: |
lincul: |
inc word ptr [bx] |
je LINC_HIGH_WORD |
ret |
.even |
LINC_HIGH_WORD: |
inc word ptr 2[bx] |
ret |
|
ASM_END |
|
// for access to RAM area which is used by interrupt vectors |
1014,8 → 1024,10
} |
} |
|
static char bios_svn_version_string[] = "$Revision: 1.13 $ $Date: 2009-03-05 00:26:53 $"; |
static char bios_svn_version_string[] = "$Version: 0.4.3 $ $Date: Tue, 10 Mar 2009 21:02:08 +0100 $"; |
|
#define BIOS_COPYRIGHT_STRING "(c) 2009 Zeus Gomez Marmolejo and (c) 2002 MandrakeSoft S.A." |
|
//-------------------------------------------------------------------------- |
// print_bios_banner |
// displays a the bios version |
1042,7 → 1054,7
// http://www.phoenix.com/en/Customer+Services/White+Papers-Specs/pc+industry+specifications.htm |
//-------------------------------------------------------------------------- |
|
static char drivetypes[][20]={"", "Floppy flash image" }; |
static char drivetypes[][20]={"", "Floppy flash image", "Compact Flash" }; |
|
static void |
init_boot_vectors() |
1062,6 → 1074,11
memcpyb(IPL_SEG, IPL_TABLE_OFFSET + count * sizeof (e), ss, &e, sizeof (e)); |
count++; |
|
/* First HDD */ |
e.type = IPL_TYPE_HARDDISK; e.flags = 0; e.vector = 0; e.description = 0; e.reserved = 0; |
memcpyb(IPL_SEG, IPL_TABLE_OFFSET + count * sizeof (e), ss, &e, sizeof (e)); |
count++; |
|
/* Remember how many devices we have */ |
write_word(IPL_SEG, IPL_COUNT_OFFSET, count); |
/* Not tried booting anything yet */ |
1501,27 → 1518,495
int13_harddisk(DS, ES, DI, SI, BP, ELDX, BX, DX, CX, AX, IP, CS, FLAGS) |
Bit16u DS, ES, DI, SI, BP, ELDX, BX, DX, CX, AX, IP, CS, FLAGS; |
{ |
Bit8u drive, num_sectors, sector, head, status; |
Bit8u drive_map; |
Bit8u n_drives; |
Bit16u max_cylinder, cylinder; |
Bit16u hd_cylinders; |
Bit8u hd_heads, hd_sectors; |
Bit8u sector_count; |
Bit16u tempbx; |
|
Bit32u log_sector; |
|
write_byte(0x0040, 0x008e, 0); // clear completion flag |
|
/* at this point, DL is >= 0x80 to be passed from the floppy int13h |
handler code */ |
/* check how many disks first (cmos reg 0x12), return an error if |
drive not present */ |
drive_map = 1; |
n_drives = 1; |
|
if (!(drive_map & (1<<(GET_ELDL()&0x7f)))) { /* allow 0, 1, or 2 disks */ |
SET_AH(0x01); |
SET_DISK_RET_STATUS(0x01); |
SET_CF(); /* error occurred */ |
return; |
} |
|
switch (GET_AH()) { |
|
case 0x00: /* disk controller reset */ |
|
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
set_diskette_ret_status(0); |
set_diskette_current_cyl(0, 0); /* current cylinder, diskette 1 */ |
set_diskette_current_cyl(1, 0); /* current cylinder, diskette 2 */ |
CLEAR_CF(); /* successful */ |
return; |
break; |
|
case 0x01: /* read disk status */ |
status = read_byte(0x0040, 0x0074); |
SET_AH(status); |
SET_DISK_RET_STATUS(0); |
/* set CF if error status read */ |
if (status) SET_CF(); |
else CLEAR_CF(); |
return; |
break; |
|
case 0x04: // verify disk sectors |
case 0x02: // read disk sectors |
drive = GET_ELDL(); |
|
// get_hd_geometry(drive, &hd_cylinders, &hd_heads, &hd_sectors); |
// fixed geometry: |
hd_cylinders = 993; |
hd_heads = 16; |
hd_sectors = 63; |
|
num_sectors = GET_AL(); |
cylinder = (GET_CL() & 0x00c0) << 2 | GET_CH(); |
sector = (GET_CL() & 0x3f); |
head = GET_DH(); |
|
if ( (cylinder >= hd_cylinders) || |
(sector > hd_sectors) || |
(head >= hd_heads) ) { |
SET_AH(1); |
SET_DISK_RET_STATUS(1); |
SET_CF(); /* error occurred */ |
return; |
} |
|
if ( GET_AH() == 0x04 ) { |
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
CLEAR_CF(); |
return; |
} |
|
log_sector = ((Bit32u)cylinder) * ((Bit32u)hd_heads) * ((Bit32u)hd_sectors) |
+ ((Bit32u)head) * ((Bit32u)hd_sectors) |
+ ((Bit32u)sector) - 1; |
|
sector_count = 0; |
tempbx = BX; |
|
ASM_START |
sti ;; enable higher priority interrupts |
ASM_END |
|
while (1) { |
ASM_START |
;; store temp bx in real DI register |
push bp |
mov bp, sp |
mov di, _int13_harddisk.tempbx + 2 [bp] |
pop bp |
|
;; adjust if there will be an overrun |
cmp di, #0xfe00 |
jbe i13_f02_no_adjust |
i13_f02_adjust: |
sub di, #0x0200 ; sub 512 bytes from offset |
mov ax, es |
add ax, #0x0020 ; add 512 to segment |
mov es, ax |
|
i13_f02_no_adjust: |
; timeout = TIMEOUT; |
mov cx, #0xffff |
|
; while((timeout > 0) && (!(CSR_ACE_STATUSL & ACE_STATUSL_CFCMDRDY))) timeout--; |
mov dx, #0xe204 |
|
i13_f02_ace_statusl2: |
in ax, dx |
and ax, #0x100 |
loopz i13_f02_ace_statusl2 |
|
; if(timeout == 0) return 0; |
cmp cx, #0 |
jnz i13_f02_success2 |
ASM_END |
printf("i13_f02(1): Timeout\n"); |
ASM_START |
jmp _int13_fail |
|
i13_f02_success2: |
; CSR_ACE_MLBAL = blocknr & 0x0000ffff; |
push bp |
mov bp, sp |
mov ax, _int13_harddisk.log_sector + 2 [bp] |
mov dx, #0xe210 |
out dx, ax |
|
; CSR_ACE_MLBAH = (blocknr & 0x0fff0000) >> 16; |
mov ax, _int13_harddisk.log_sector + 4 [bp] |
mov dx, #0xe212 |
out dx, ax |
pop bp |
|
; CSR_ACE_SECCMD = ACE_SECCMD_READ|0x01; |
mov ax, #0x0301 |
mov dx, #0xe214 |
out dx, ax |
|
; CSR_ACE_CTLL |= ACE_CTLL_CFGRESET; |
mov dx, #0xe218 |
in ax, dx |
or ax, #0x0080 |
out dx, ax |
|
; buffer_count = 16; |
mov si, #16 |
|
; while(buffer_count > 0) { |
i13_f02_cond_loop: |
cmp si, #0 |
jbe i13_f02_exit_loop |
|
; timeout = TIMEOUT; |
mov cx, #0xffff |
mov bx, #0x000f |
|
; while((timeout > 0) && (!(CSR_ACE_STATUSL & ACE_STATUSL_DATARDY))) timeout--; |
mov dx, #0xe204 |
i13_f02_ace_statusl3: |
in ax, dx |
and ax, #0x20 |
loopz i13_f02_ace_statusl3 |
|
; if(timeout == 0) return 0; |
cmp cx, #0 |
jnz i13_f02_success3 |
dec bx |
mov cx, #0xffff |
jne i13_f02_ace_statusl3 |
ASM_END |
printf("i13_f02(2): Timeout\n"); |
ASM_START |
jmp _int13_fail |
|
i13_f02_success3: |
; for(i=0;i<16;i++) { |
mov cx, #16 |
; *bufw = CSR_ACE_DATA; |
mov dx, #0xe240 |
i13_f02_ace_data: |
in ax, dx |
eseg |
mov [di], ax |
; bufw++; |
add di, #2 |
; } |
loop i13_f02_ace_data |
|
; buffer_count--; |
dec si |
jmp i13_f02_cond_loop |
|
; } |
|
i13_f02_exit_loop: |
; CSR_ACE_CTLL &= ~ACE_CTLL_CFGRESET; |
mov dx, #0xe218 |
in ax, dx |
and ax, #0xff7f |
out dx, ax |
|
i13_f02_done: |
;; store real DI register back to temp bx |
push bp |
mov bp, sp |
mov _int13_harddisk.tempbx + 2 [bp], di |
pop bp |
ASM_END |
|
sector_count++; |
log_sector++; |
num_sectors--; |
if (num_sectors) continue; |
else break; |
} |
|
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
SET_AL(sector_count); |
CLEAR_CF(); /* successful */ |
return; |
break; |
|
case 0x03: /* write disk sectors */ |
drive = GET_ELDL (); |
|
// get_hd_geometry(drive, &hd_cylinders, &hd_heads, &hd_sectors); |
// fixed geometry: |
hd_cylinders = 993; |
hd_heads = 16; |
hd_sectors = 63; |
|
num_sectors = GET_AL(); |
cylinder = GET_CH(); |
cylinder |= ( ((Bit16u) GET_CL()) << 2) & 0x300; |
sector = (GET_CL() & 0x3f); |
head = GET_DH(); |
|
if ( (cylinder >= hd_cylinders) || |
(sector > hd_sectors) || |
(head >= hd_heads) ) { |
SET_AH( 1); |
SET_DISK_RET_STATUS(1); |
SET_CF(); /* error occurred */ |
return; |
} |
|
log_sector = ((Bit32u)cylinder) * ((Bit32u)hd_heads) * ((Bit32u)hd_sectors) |
+ ((Bit32u)head) * ((Bit32u)hd_sectors) |
+ ((Bit32u)sector) - 1; |
|
sector_count = 0; |
tempbx = BX; |
|
ASM_START |
sti ;; enable higher priority interrupts |
ASM_END |
|
while (1) { |
ASM_START |
;; store temp bx in real SI register |
push bp |
mov bp, sp |
mov si, _int13_harddisk.tempbx + 2 [bp] |
pop bp |
|
;; adjust if there will be an overrun |
cmp si, #0xfe00 |
jbe i13_f03_no_adjust |
i13_f03_adjust: |
sub si, #0x0200 ; sub 512 bytes from offset |
mov ax, es |
add ax, #0x0020 ; add 512 to segment |
mov es, ax |
|
i13_f03_no_adjust: |
; timeout = TIMEOUT; |
mov cx, #0xffff |
|
; while((timeout > 0) && (!(CSR_ACE_STATUSL & ACE_STATUSL_CFCMDRDY))) timeout--; |
mov dx, #0xe204 |
|
i13_f03_ace_statusl2: |
in ax, dx |
and ax, #0x100 |
loopz i13_f03_ace_statusl2 |
|
; if(timeout == 0) return 0; |
cmp cx, #0 |
jnz i13_f03_success2 |
ASM_END |
printf("i13_f03(1): Timeout\n"); |
ASM_START |
jmp _int13_fail |
|
i13_f03_success2: |
; CSR_ACE_MLBAL = blocknr & 0x0000ffff; |
push bp |
mov bp, sp |
mov ax, _int13_harddisk.log_sector + 2 [bp] |
mov dx, #0xe210 |
out dx, ax |
|
; CSR_ACE_MLBAH = (blocknr & 0x0fff0000) >> 16; |
mov ax, _int13_harddisk.log_sector + 4 [bp] |
mov dx, #0xe212 |
out dx, ax |
pop bp |
|
; CSR_ACE_SECCMD = ACE_SECCMD_WRITE|0x01; |
mov ax, #0x0401 |
mov dx, #0xe214 |
out dx, ax |
|
; CSR_ACE_CTLL |= ACE_CTLL_CFGRESET; |
mov dx, #0xe218 |
in ax, dx |
or ax, #0x0080 |
out dx, ax |
|
; buffer_count = 16; |
mov di, #16 |
|
; while(buffer_count > 0) { |
i13_f03_cond_loop: |
cmp di, #0 |
jbe i13_f03_exit_loop |
|
; timeout = TIMEOUT; |
mov cx, #0xffff |
mov bx, #0x000f |
|
; while((timeout > 0) && (!(CSR_ACE_STATUSL & ACE_STATUSL_DATARDY))) timeout--; |
mov dx, #0xe204 |
i13_f03_ace_statusl3: |
in ax, dx |
and ax, #0x20 |
loopz i13_f03_ace_statusl3 |
|
; if(timeout == 0) return 0; |
cmp cx, #0 |
jnz i13_f03_success3 |
dec bx |
mov cx, #0xffff |
jne i13_f03_ace_statusl3 |
ASM_END |
printf("i13_f03(2): Timeout\n"); |
ASM_START |
jmp _int13_fail |
|
i13_f03_success3: |
; for(i=0;i<16;i++) { |
mov cx, #16 |
; *bufw = CSR_ACE_DATA; |
mov dx, #0xe240 |
i13_f03_ace_data: |
eseg |
mov ax, [si] |
out dx, ax |
; bufw++; |
add si, #2 |
; } |
loop i13_f03_ace_data |
|
; buffer_count--; |
dec di |
jmp i13_f03_cond_loop |
|
; } |
|
i13_f03_exit_loop: |
; CSR_ACE_CTLL &= ~ACE_CTLL_CFGRESET; |
mov dx, #0xe218 |
in ax, dx |
and ax, #0xff7f |
out dx, ax |
|
i13_f03_done: |
;; store real SI register back to temp bx |
push bp |
mov bp, sp |
mov _int13_harddisk.tempbx + 2 [bp], si |
pop bp |
ASM_END |
|
sector_count++; |
log_sector++; |
num_sectors--; |
if (num_sectors) continue; |
else break; |
} |
|
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
SET_AL(sector_count); |
CLEAR_CF(); /* successful */ |
return; |
break; |
|
case 0x08: |
|
drive = GET_ELDL (); |
|
// get_hd_geometry(drive, &hd_cylinders, &hd_heads, &hd_sectors); |
// fixed geometry: |
hd_cylinders = 993; |
hd_heads = 16; |
hd_sectors = 63; |
|
max_cylinder = hd_cylinders - 2; /* 0 based */ |
SET_AL(0); |
SET_CH(0); |
SET_CL(0); |
SET_DH(0); |
SET_DL(0); /* FIXME returns 0, 1, or n hard drives */ |
SET_CH(max_cylinder & 0xff); |
SET_CL(((max_cylinder >> 2) & 0xc0) | (hd_sectors & 0x3f)); |
SET_DH(hd_heads - 1); |
SET_DL(n_drives); /* returns 0, 1, or 2 hard drives */ |
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
CLEAR_CF(); /* successful */ |
|
// FIXME should set ES & DI |
return; |
break; |
|
goto int13_fail; |
case 0x09: /* initialize drive parameters */ |
case 0x0c: /* seek to specified cylinder */ |
case 0x0d: /* alternate disk reset */ |
case 0x10: /* check drive ready */ |
case 0x11: /* recalibrate */ |
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
CLEAR_CF(); /* successful */ |
return; |
break; |
|
case 0x14: /* controller internal diagnostic */ |
SET_AH(0); |
SET_DISK_RET_STATUS(0); |
CLEAR_CF(); /* successful */ |
SET_AL(0); |
return; |
break; |
|
case 0x15: /* read disk drive size */ |
drive = GET_ELDL(); |
// get_hd_geometry(drive, &hd_cylinders, &hd_heads, &hd_sectors); |
// fixed geometry: |
hd_cylinders = 993; |
hd_heads = 16; |
hd_sectors = 63; |
|
ASM_START |
push bp |
mov bp, sp |
mov al, _int13_harddisk.hd_heads + 2 [bp] |
mov ah, _int13_harddisk.hd_sectors + 2 [bp] |
mul al, ah ;; ax = heads * sectors |
mov bx, _int13_harddisk.hd_cylinders + 2 [bp] |
dec bx ;; use (cylinders - 1) ??? |
mul ax, bx ;; dx:ax = (cylinders -1) * (heads * sectors) |
;; now we need to move the 32bit result dx:ax to what the |
;; BIOS wants which is cx:dx. |
;; and then into CX:DX on the stack |
mov _int13_harddisk.CX + 2 [bp], dx |
mov _int13_harddisk.DX + 2 [bp], ax |
pop bp |
ASM_END |
SET_AH(3); // hard disk accessible |
SET_DISK_RET_STATUS(0); // ??? should this be 0 |
CLEAR_CF(); // successful |
return; |
break; |
|
default: |
BX_INFO("int13_harddisk: function %02xh unsupported, returns fail\n", GET_AH()); |
goto int13_fail; |
break; |
} |
|
ASM_START |
_int13_fail: |
ASM_END |
int13_fail: |
SET_AH(0x01); // defaults to invalid function in AH or invalid parameter |
int13_fail_noah: |
1681,9 → 2166,9
Bit8u drive; |
Bit8u cyl; |
{ |
/* TEMP HACK: FOR MSDOS */ |
/* TEMP HACK: FOR MSDOS |
if (drive > 1) |
drive = 1; |
drive = 1; */ |
/* BX_PANIC("set_diskette_current_cyl(): drive > 1\n"); */ |
write_byte(0x0040, 0x0094+drive, cyl); |
} |
1725,7 → 2210,7
bootdev >>= 4 * seq_nr; |
bootdev &= 0xf; |
*/ |
bootdev = 0x1; |
bootdev = 0x2; // 1: flopy disk, 2: hard disk |
|
/* Read user selected device */ |
bootfirst = read_word(IPL_SEG, IPL_BOOTFIRST_OFFSET); |
1912,6 → 2397,16
; shl eax, #16 |
|
int13_out: |
; |
; ZEUS HACK: put IF flag on. |
; Seems that MS-DOS does a 'cli' before calling this |
; but after int13 it doesn't set the interrupts back |
; |
mov bp, sp |
mov ax, 24[bp] ; FLAGS location |
or ax, #0x0200 ; IF on |
mov 24[bp], ax |
|
pop ds |
pop es |
; popa ; we do this instead: |
1989,7 → 2484,80
int1c_handler: ;; User Timer Tick |
iret |
|
;-------------------- |
;- POST: HARD DRIVE - |
;-------------------- |
; relocated here because the primary POST area isnt big enough. |
hard_drive_post: |
// IRQ 14 = INT 76h |
// INT 76h calls INT 15h function ax=9100 |
|
xor ax, ax |
mov ds, ax |
mov 0x0474, al /* hard disk status of last operation */ |
mov 0x0477, al /* hard disk port offset (XT only ???) */ |
mov 0x048c, al /* hard disk status register */ |
mov 0x048d, al /* hard disk error register */ |
mov 0x048e, al /* hard disk task complete flag */ |
mov al, #0x01 |
mov 0x0475, al /* hard disk number attached */ |
mov al, #0xc0 |
mov 0x0476, al /* hard disk control byte */ |
SET_INT_VECTOR(0x13, #0xF000, #int13_handler) |
SET_INT_VECTOR(0x76, #0xF000, #int76_handler) |
|
;; Initialize the sysace controller |
; CSR_ACE_BUSMODE = ACE_BUSMODE_16BIT; |
mov dx, #0xe200 |
mov ax, #0x0001 |
out dx, ax |
|
; if(!(CSR_ACE_STATUSL & ACE_STATUSL_CFDETECT)) return 0; |
mov dx, #0xe204 |
in ax, dx |
and ax, #0x0010 |
jne cf_detect |
hlt ;; error |
|
cf_detect: |
; if((CSR_ACE_ERRORL != 0) || (CSR_ACE_ERRORH != 0)) return 0; |
mov dx, #0xe208 |
in ax, dx |
cmp ax, #0x0 |
jne error_l |
mov dx, #0xe20a |
in ax, dx |
cmp ax, #0x0 |
je lock_req |
error_l: |
hlt |
|
lock_req: |
; CSR_ACE_CTLL |= ACE_CTLL_LOCKREQ; |
mov dx, #0xe218 |
in ax, dx |
or ax, #0x2 |
out dx, ax |
|
; timeout = TIMEOUT; |
mov cx, #0xffff |
|
; while((timeout > 0) && (!(CSR_ACE_STATUSL & ACE_STATUSL_MPULOCK))) timeout--; |
mov dx, #0xe204 |
ace_statusl: |
in ax, dx |
and ax, #0x2 |
loopz ace_statusl |
|
; if(timeout == 0) return 0; |
cmp cx, #0x0 |
jnz success |
hlt ;; error obtaining lock |
|
success: |
ret |
|
|
;-------------------- |
;- POST: EBDA segment |
;-------------------- |
2000,6 → 2568,20
mov word ptr [0x40E], #EBDA_SEG |
ret;; |
|
;-------------------- |
int76_handler: |
;; record completion in BIOS task complete flag |
push ax |
push ds |
mov ax, #0x0040 |
mov ds, ax |
mov 0x008E, #0xff |
; call eoi_both_pics |
pop ds |
pop ax |
iret |
|
|
rom_checksum: |
push ax |
push bx |
2225,6 → 2807,10
;; EBDA setup |
call ebda_post |
|
;; PIT setup |
SET_INT_VECTOR(0x08, #0xF000, #int08_handler) |
;; int 1C already points at dummy_iret_handler (above) |
|
;; Keyboard |
SET_INT_VECTOR(0x09, #0xF000, #int09_handler) |
SET_INT_VECTOR(0x16, #0xF000, #int16_handler) |
2267,8 → 2853,10
|
call _print_bios_banner |
|
;; Floppy setup |
SET_INT_VECTOR(0x13, #0xF000, #int13_handler) |
;; |
;; Hard Drive setup |
;; |
call hard_drive_post |
|
call _init_boot_vectors |
|
2548,6 → 3136,67
pop ds |
iret |
|
;--------- |
;- INT08 - |
;--------- |
.org 0xfea5 ; INT 08h System Timer ISR Entry Point |
int08_handler: |
sti |
push ax |
push bx |
push ds |
xor ax, ax |
mov ds, ax |
|
mov ax, 0x046c ;; get ticks dword |
mov bx, 0x046e |
inc ax |
jne i08_linc_done |
inc bx ;; inc high word |
|
i08_linc_done: |
push bx |
;; compare eax to one days worth of timer ticks at 18.2 hz |
sub bx, #0x0018 |
jne i08_lcmp_done |
cmp ax, #0x00B0 |
jb i08_lcmp_b_and_lt |
jge i08_lcmp_done |
inc bx |
jmp i08_lcmp_done |
|
i08_lcmp_b_and_lt: |
dec bx |
|
i08_lcmp_done: |
pop bx |
jb int08_store_ticks |
;; there has been a midnight rollover at this point |
xor ax, ax ;; zero out counter |
xor bx, bx |
inc BYTE 0x0470 ;; increment rollover flag |
|
int08_store_ticks: |
mov 0x046c, ax ;; store new ticks dword |
mov 0x046e, bx |
;; chain to user timer tick INT #0x1c |
//pushf |
//;; call_ep [ds:loc] |
//CALL_EP( 0x1c << 2 ) |
int #0x1c |
cli |
;; call eoi_master_pic |
pop ds |
pop bx |
pop ax |
iret |
|
.org 0xfef3 ; Initial Interrupt Vector Offsets Loaded by POST |
|
|
.org 0xff00 |
.ascii BIOS_COPYRIGHT_STRING |
|
;------------------------------------------------ |
;- IRET Instruction for Dummy Interrupt Handler - |
;------------------------------------------------ |
/vgabios.c
240,7 → 240,7
|
#if defined(USE_BX_INFO) || defined(DEBUG) |
msg_vga_init: |
.ascii "VGABios $Id: vgabios.c,v 1.9 2009-03-05 19:58:40 zeus Exp $" |
.ascii "VGABios $Id: vgabios.c,v 1.66 2006/07/10 07:47:51 vruppert Exp $" |
.byte 0x0d,0x0a,0x00 |
#endif |
ASM_END |