Return CDEMU parameters to ebda segment (instead of using globals).

The cdemu is setup in the boot stage after globals are made
    read-only.  So, globals can't be used.
Also, move hdcount from a global to BDA (it should be in BDA).
Don't attempt to set blksize/sector count in atapi_is_ready() - it's
    not useful.

diff --git a/src/ata.c b/src/ata.c
index 7e31002b5d342cda900f709e707e4a57916a52f5..3694c3b9aa4d80606286cca4cb83b5c40469e8a6 100644 (file)
--- a/src/ata.c
+++ b/src/ata.c
@@ -779,9 +779,9 @@ init_drive_ata(int driveid)
     setup_translation(driveid);
 
     // fill hdidmap
-    u8 hdcount = GET_GLOBAL(ATA.hdcount);
+    u8 hdcount = GET_BDA(hdcount);
     SET_GLOBAL(ATA.idmap[0][hdcount], driveid);
-    SET_GLOBAL(ATA.hdcount, ++hdcount);
+    SET_BDA(hdcount, ++hdcount);
 
     // Fill "fdpt" structure.
     fill_fdpt(driveid);
@@ -937,9 +937,6 @@ hard_drive_setup()
     ata_init();
     ata_detect();
 
-    // Store the device count
-    SET_BDA(disk_count, GET_GLOBAL(ATA.hdcount));
-
     SET_BDA(disk_control_byte, 0xc0);
 
     enable_hwirq(14, entry_76);

diff --git a/src/biosvar.h b/src/biosvar.h
index c8a1cce9a55d2194ba8ac2ab19c9281d634981c4..cd8e0ac903824b0c86579d04996ae5bd6d594c1b 100644 (file)
--- a/src/biosvar.h
+++ b/src/biosvar.h
@@ -69,7 +69,7 @@ struct bios_data_area_s {
     u8 break_flag;
     u16 soft_reset_flag;
     u8 disk_last_status;
-    u8 disk_count;
+    u8 hdcount;
     u8 disk_control_byte;
     u8 port_disk;
     u8 lpt_timeout[4];
@@ -148,6 +148,24 @@ struct dpte_s {
     u8  checksum;
 };
 
+// ElTorito Device Emulation data
+struct cdemu_s {
+    u8  active;
+    u8  media;
+    u8  emulated_drive;
+    u8  controller_index;
+    u16 device_spec;
+    u32 ilba;
+    u16 buffer_segment;
+    u16 load_segment;
+    u16 sector_count;
+
+    // Virtual device
+    u16 heads;
+    u16 cylinders;
+    u16 spt;
+};
+
 struct fdpt_s {
     u16 cylinders;
     u8 heads;
@@ -182,7 +200,8 @@ struct extended_bios_data_area_s {
     // 0x121 - Begin custom storage.
     u8 ps2ctr;
 
-    u8 cdemu_active;
+    // El Torito Emulation data
+    struct cdemu_s cdemu;
 
     // Count of transferred sectors and bytes to/from disk
     u16 sector_count;

diff --git a/src/boot.c b/src/boot.c
index 7b64e8612473d1530f1f2ecd41dae7f0f138da5e..df3647dad438e09b7adb50928d04c2eaec352899 100644 (file)
--- a/src/boot.c
+++ b/src/boot.c
@@ -152,8 +152,9 @@ try_boot(u16 seq_nr)
             return;
         }
 
-        bootdrv = GET_GLOBAL(CDEMU.emulated_drive);
-        bootseg = GET_GLOBAL(CDEMU.load_segment);
+        u16 ebda_seg = get_ebda_seg();
+        bootdrv = GET_EBDA2(ebda_seg, cdemu.emulated_drive);
+        bootseg = GET_EBDA2(ebda_seg, cdemu.load_segment);
         /* Canonicalize bootseg:bootip */
         bootip = (bootseg & 0x0fff) << 4;
         bootseg &= 0xf000;

diff --git a/src/cdrom.c b/src/cdrom.c
index 1fe2ebc1f373622e176f67e5a8656905ee521b9d..00ecc7170aca988b00a58dc4c356b7ab1f97e447 100644 (file)
--- a/src/cdrom.c
+++ b/src/cdrom.c
@@ -11,8 +11,6 @@
 #include "bregs.h" // struct bregs
 #include "biosvar.h" // GET_EBDA
 
-struct cdemu_s CDEMU VAR16_32;
-
 
 /****************************************************************
  * CDROM functions
@@ -187,7 +185,7 @@ cdrom_13(struct bregs *regs, u8 device)
 __always_inline int
 cdrom_read_emu(u16 biosid, u32 vlba, u32 count, void *far_buffer)
 {
-    u32 ilba = GET_GLOBAL(CDEMU.ilba);
+    u32 ilba = GET_EBDA(cdemu.ilba);
     return cdrom_read_512(biosid, ilba * 4 + vlba, count, far_buffer);
 }
 
@@ -195,9 +193,10 @@ cdrom_read_emu(u16 biosid, u32 vlba, u32 count, void *far_buffer)
 static void
 cdemu_1308(struct bregs *regs, u8 device)
 {
-    u16 nlc   = GET_GLOBAL(CDEMU.vdevice.cylinders) - 1;
-    u16 nlh   = GET_GLOBAL(CDEMU.vdevice.heads) - 1;
-    u16 nlspt = GET_GLOBAL(CDEMU.vdevice.spt);
+    u16 ebda_seg = get_ebda_seg();
+    u16 nlc   = GET_EBDA2(ebda_seg, cdemu.cylinders) - 1;
+    u16 nlh   = GET_EBDA2(ebda_seg, cdemu.heads) - 1;
+    u16 nlspt = GET_EBDA2(ebda_seg, cdemu.spt);
 
     regs->al = 0x00;
     regs->bl = 0x00;
@@ -207,7 +206,7 @@ cdemu_1308(struct bregs *regs, u8 device)
     // FIXME ElTorito Various. should send the real count of drives 1 or 2
     // FIXME ElTorito Harddisk. should send the HD count
     regs->dl = 0x02;
-    u8 media = GET_GLOBAL(CDEMU.media);
+    u8 media = GET_EBDA2(ebda_seg, cdemu.media);
     if (media <= 3)
         regs->bl = media * 2;
 
@@ -222,8 +221,9 @@ cdemu_13(struct bregs *regs)
 {
     //debug_stub(regs);
 
-    u8 device  = GET_GLOBAL(CDEMU.controller_index) * 2;
-    device += GET_GLOBAL(CDEMU.device_spec);
+    u16 ebda_seg = get_ebda_seg();
+    u8 device  = GET_EBDA2(ebda_seg, cdemu.controller_index) * 2;
+    device += GET_EBDA2(ebda_seg, cdemu.device_spec);
 
     switch (regs->ah) {
     // These functions are the same as for hard disks
@@ -277,23 +277,25 @@ void
 cdemu_134b(struct bregs *regs)
 {
     // FIXME ElTorito Hardcoded
+    u16 ebda_seg = get_ebda_seg();
     SET_INT13ET(regs, size, 0x13);
-    SET_INT13ET(regs, media, GET_GLOBAL(CDEMU.media));
-    SET_INT13ET(regs, emulated_drive, GET_GLOBAL(CDEMU.emulated_drive));
-    SET_INT13ET(regs, controller_index, GET_GLOBAL(CDEMU.controller_index));
-    SET_INT13ET(regs, ilba, GET_GLOBAL(CDEMU.ilba));
-    SET_INT13ET(regs, device_spec, GET_GLOBAL(CDEMU.device_spec));
-    SET_INT13ET(regs, buffer_segment, GET_GLOBAL(CDEMU.buffer_segment));
-    SET_INT13ET(regs, load_segment, GET_GLOBAL(CDEMU.load_segment));
-    SET_INT13ET(regs, sector_count, GET_GLOBAL(CDEMU.sector_count));
-    SET_INT13ET(regs, cylinders, GET_GLOBAL(CDEMU.vdevice.cylinders));
-    SET_INT13ET(regs, sectors, GET_GLOBAL(CDEMU.vdevice.spt));
-    SET_INT13ET(regs, heads, GET_GLOBAL(CDEMU.vdevice.heads));
+    SET_INT13ET(regs, media, GET_EBDA2(ebda_seg, cdemu.media));
+    SET_INT13ET(regs, emulated_drive, GET_EBDA2(ebda_seg, cdemu.emulated_drive));
+    SET_INT13ET(regs, controller_index
+                , GET_EBDA2(ebda_seg, cdemu.controller_index));
+    SET_INT13ET(regs, ilba, GET_EBDA2(ebda_seg, cdemu.ilba));
+    SET_INT13ET(regs, device_spec, GET_EBDA2(ebda_seg, cdemu.device_spec));
+    SET_INT13ET(regs, buffer_segment, GET_EBDA2(ebda_seg, cdemu.buffer_segment));
+    SET_INT13ET(regs, load_segment, GET_EBDA2(ebda_seg, cdemu.load_segment));
+    SET_INT13ET(regs, sector_count, GET_EBDA2(ebda_seg, cdemu.sector_count));
+    SET_INT13ET(regs, cylinders, GET_EBDA2(ebda_seg, cdemu.cylinders));
+    SET_INT13ET(regs, sectors, GET_EBDA2(ebda_seg, cdemu.spt));
+    SET_INT13ET(regs, heads, GET_EBDA2(ebda_seg, cdemu.heads));
 
     // If we have to terminate emulation
     if (regs->al == 0x00) {
         // FIXME ElTorito Various. Should be handled accordingly to spec
-        SET_EBDA(cdemu_active, 0x00); // bye bye
+        SET_EBDA2(ebda_seg, cdemu.active, 0x00); // bye bye
     }
 
     disk_ret(regs, DISK_RET_SUCCESS);
@@ -378,11 +380,10 @@ atapi_is_ready(u16 device)
         | (u32) buf[6] << 8
         | (u32) buf[7] << 0;
 
-    if (block_len != 2048 && block_len != 512) {
+    if (block_len != GET_GLOBAL(ATA.devices[device].blksize)) {
         printf("Unsupported sector size %u\n", block_len);
         return -1;
     }
-    SET_GLOBAL(ATA.devices[device].blksize, block_len);
 
     u32 sectors = (u32) buf[0] << 24
         | (u32) buf[1] << 16
@@ -390,11 +391,7 @@ atapi_is_ready(u16 device)
         | (u32) buf[3] << 0;
 
     dprintf(6, "sectors=%u\n", sectors);
-    if (block_len == 2048)
-        sectors <<= 2; /* # of sectors in 512-byte "soft" sector */
-    if (sectors != GET_GLOBAL(ATA.devices[device].sectors))
-        printf("%dMB medium detected\n", sectors>>(20-9));
-    SET_GLOBAL(ATA.devices[device].sectors, sectors);
+    printf("%dMB medium detected\n", sectors>>(20-11));
     return 0;
 }
 
@@ -480,23 +477,24 @@ cdrom_boot()
     if (buffer[0x20] != 0x88)
         return 11; // Bootable
 
+    u16 ebda_seg = get_ebda_seg();
     u8 media = buffer[0x21];
-    SET_GLOBAL(CDEMU.media, media);
+    SET_EBDA2(ebda_seg, cdemu.media, media);
 
-    SET_GLOBAL(CDEMU.controller_index, device/2);
-    SET_GLOBAL(CDEMU.device_spec, device%2);
+    SET_EBDA2(ebda_seg, cdemu.controller_index, device/2);
+    SET_EBDA2(ebda_seg, cdemu.device_spec, device%2);
 
     u16 boot_segment = *(u16*)&buffer[0x22];
     if (!boot_segment)
         boot_segment = 0x07C0;
-    SET_GLOBAL(CDEMU.load_segment, boot_segment);
-    SET_GLOBAL(CDEMU.buffer_segment, 0x0000);
+    SET_EBDA2(ebda_seg, cdemu.load_segment, boot_segment);
+    SET_EBDA2(ebda_seg, cdemu.buffer_segment, 0x0000);
 
     u16 nbsectors = *(u16*)&buffer[0x26];
-    SET_GLOBAL(CDEMU.sector_count, nbsectors);
+    SET_EBDA2(ebda_seg, cdemu.sector_count, nbsectors);
 
     lba = *(u32*)&buffer[0x28];
-    SET_GLOBAL(CDEMU.ilba, lba);
+    SET_EBDA2(ebda_seg, cdemu.ilba, lba);
 
     // And we read the image in memory
     ret = cdrom_read_emu(device, 0, nbsectors, MAKE_FARPTR(boot_segment, 0));
@@ -508,7 +506,7 @@ cdrom_boot()
 
         // FIXME ElTorito Hardcoded. cdrom is hardcoded as device 0xE0.
         // Win2000 cd boot needs to know it booted from cd
-        SET_GLOBAL(CDEMU.emulated_drive, 0xE0);
+        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0xE0);
 
         return 0;
     }
@@ -521,44 +519,44 @@ cdrom_boot()
     // number of devices
     if (media < 4) {
         // Floppy emulation
-        SET_GLOBAL(CDEMU.emulated_drive, 0x00);
+        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0x00);
         SETBITS_BDA(equipment_list_flags, 0x41);
     } else {
         // Harddrive emulation
-        SET_GLOBAL(CDEMU.emulated_drive, 0x80);
-        SET_GLOBAL(ATA.hdcount, GET_GLOBAL(ATA.hdcount) + 1);
+        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0x80);
+        SET_BDA(hdcount, GET_BDA(hdcount) + 1);
     }
 
     // Remember the media type
     switch (media) {
     case 0x01:  // 1.2M floppy
-        SET_GLOBAL(CDEMU.vdevice.spt, 15);
-        SET_GLOBAL(CDEMU.vdevice.cylinders, 80);
-        SET_GLOBAL(CDEMU.vdevice.heads, 2);
+        SET_EBDA2(ebda_seg, cdemu.spt, 15);
+        SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
+        SET_EBDA2(ebda_seg, cdemu.heads, 2);
         break;
     case 0x02:  // 1.44M floppy
-        SET_GLOBAL(CDEMU.vdevice.spt, 18);
-        SET_GLOBAL(CDEMU.vdevice.cylinders, 80);
-        SET_GLOBAL(CDEMU.vdevice.heads, 2);
+        SET_EBDA2(ebda_seg, cdemu.spt, 18);
+        SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
+        SET_EBDA2(ebda_seg, cdemu.heads, 2);
         break;
     case 0x03:  // 2.88M floppy
-        SET_GLOBAL(CDEMU.vdevice.spt, 36);
-        SET_GLOBAL(CDEMU.vdevice.cylinders, 80);
-        SET_GLOBAL(CDEMU.vdevice.heads, 2);
+        SET_EBDA2(ebda_seg, cdemu.spt, 36);
+        SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
+        SET_EBDA2(ebda_seg, cdemu.heads, 2);
         break;
     case 0x04: { // Harddrive
         u16 spt = GET_FARVAR(boot_segment,*(u8*)(446+6));
         u16 cyl = (spt << 2) + GET_FARVAR(boot_segment,*(u8*)(446+7)) + 1;
         u16 heads = GET_FARVAR(boot_segment,*(u8*)(446+5)) + 1;
-        SET_GLOBAL(CDEMU.vdevice.spt, spt & 0x3f);
-        SET_GLOBAL(CDEMU.vdevice.cylinders, cyl);
-        SET_GLOBAL(CDEMU.vdevice.heads, heads);
+        SET_EBDA2(ebda_seg, cdemu.spt, spt & 0x3f);
+        SET_EBDA2(ebda_seg, cdemu.cylinders, cyl);
+        SET_EBDA2(ebda_seg, cdemu.heads, heads);
         break;
     }
     }
 
     // everything is ok, so from now on, the emulation is active
-    SET_EBDA(cdemu_active, 0x01);
+    SET_EBDA2(ebda_seg, cdemu.active, 0x01);
     dprintf(6, "cdemu media=%d\n", media);
 
     return 0;

diff --git a/src/disk.c b/src/disk.c
index 2b40b2fb899e4a7d40af70dd47622b2c7af12227..010b14c5b3cbf46760567d17107515e8a1e325cd 100644 (file)
--- a/src/disk.c
+++ b/src/disk.c
@@ -50,9 +50,10 @@ basic_access(struct bregs *regs, u8 device, u16 command)
         nlspt = GET_GLOBAL(ATA.devices[device].lchs.spt);
     } else {
         // Must be cd emulation.
-        nlc   = GET_GLOBAL(CDEMU.vdevice.cylinders);
-        nlh   = GET_GLOBAL(CDEMU.vdevice.heads);
-        nlspt = GET_GLOBAL(CDEMU.vdevice.spt);
+        u16 ebda_seg = get_ebda_seg();
+        nlc   = GET_EBDA2(ebda_seg, cdemu.cylinders);
+        nlh   = GET_EBDA2(ebda_seg, cdemu.heads);
+        nlspt = GET_EBDA2(ebda_seg, cdemu.spt);
     }
 
     u16 count       = regs->al;
@@ -219,7 +220,7 @@ disk_1308(struct bregs *regs, u8 device)
     u16 nlc = GET_GLOBAL(ATA.devices[device].lchs.cylinders);
     u16 nlh = GET_GLOBAL(ATA.devices[device].lchs.heads);
     u16 nlspt = GET_GLOBAL(ATA.devices[device].lchs.spt);
-    u16 count = GET_GLOBAL(ATA.hdcount);
+    u16 count = GET_BDA(hdcount);
 
     nlc = nlc - 2; /* 0 based , last sector not used */
     regs->al = 0;
@@ -662,8 +663,9 @@ handle_13(struct bregs *regs)
             cdemu_134b(regs);
             return;
         }
-        if (GET_EBDA(cdemu_active)) {
-            if (drive == GET_GLOBAL(CDEMU.emulated_drive)) {
+        u16 ebda_seg = get_ebda_seg();
+        if (GET_EBDA2(ebda_seg, cdemu.active)) {
+            if (drive == GET_EBDA2(ebda_seg, cdemu.emulated_drive)) {
                 cdemu_13(regs);
                 return;
             }

diff --git a/src/disk.h b/src/disk.h
index a8b4ed902ecbb34c462c752f1b63c555ae1e76fb..d091c7f04c9f6961630dc43332864cdd1d631254 100644 (file)
--- a/src/disk.h
+++ b/src/disk.h
@@ -142,25 +142,10 @@ struct ata_s {
     struct ata_device_s  devices[CONFIG_MAX_ATA_DEVICES];
     //
     // map between bios hd/cd id and ata channels
-    u8 hdcount, cdcount;
+    u8 cdcount;
     u8 idmap[2][CONFIG_MAX_ATA_DEVICES];
 };
 
-// ElTorito Device Emulation data
-struct cdemu_s {
-    u8  media;
-    u8  emulated_drive;
-    u8  controller_index;
-    u16 device_spec;
-    u32 ilba;
-    u16 buffer_segment;
-    u16 load_segment;
-    u16 sector_count;
-
-    // Virtual device
-    struct chs_s  vdevice;
-};
-
 
 /****************************************************************
  * Function defs
@@ -180,7 +165,6 @@ void disk_13(struct bregs *regs, u8 device);
 void disk_13XX(struct bregs *regs, u8 device);
 
 // cdrom.c
-extern struct cdemu_s CDEMU;
 int cdrom_read_emu(u16 device, u32 lba, u32 count, void *far_buffer);
 void cdrom_13(struct bregs *regs, u8 device);
 void cdemu_13(struct bregs *regs);