X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fcdrom.c;h=6351fec0f3ac6fa257989d6b4ba1dfaa957f4b39;hb=d7a7cf3a437faa6d56d5dbb060480601ef90799e;hp=71a8b849c6ad18e5b3c99863a855457b61bc5c8a;hpb=4c0c85ab862bd042e84624ddc06cf87c0ed6cc47;p=seabios.git

diff --git a/src/cdrom.c b/src/cdrom.c
index 71a8b84..6351fec 100644
--- a/src/cdrom.c
+++ b/src/cdrom.c
@@ -1,6 +1,6 @@
-// 16bit code to access cdrom drives.
+// Support for booting from cdroms (the "El Torito" spec).
 //
-// Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
+// Copyright (C) 2008,2009  Kevin O'Connor <kevin@koconnor.net>
 // Copyright (C) 2002  MandrakeSoft S.A.
 //
 // This file may be distributed under the terms of the GNU LGPLv3 license.
@@ -9,240 +9,121 @@
 #include "util.h" // memset
 #include "bregs.h" // struct bregs
 #include "biosvar.h" // GET_EBDA
-#include "atabits.h" // ATA_TYPE_ATAPI
+#include "ata.h" // ATA_CMD_REQUEST_SENSE
+#include "blockcmd.h" // CDB_CMD_REQUEST_SENSE
 
 
 /****************************************************************
- * CDROM functions
+ * CD emulation
  ****************************************************************/
 
-// read disk drive size
-static void
-cdrom_1315(struct bregs *regs, u8 device)
-{
-    disk_ret(regs, DISK_RET_EADDRNOTFOUND);
-}
+struct drive_s *cdemu_drive_gf VAR16VISIBLE;
 
-// lock
-static void
-cdrom_134500(struct bregs *regs, u8 device)
-{
-    u16 ebda_seg = get_ebda_seg();
-    u8 locks = GET_EBDA2(ebda_seg, cdrom_locks[device]);
-    if (locks == 0xff) {
-        regs->al = 1;
-        disk_ret(regs, DISK_RET_ETOOMANYLOCKS);
-        return;
-    }
-    SET_EBDA2(ebda_seg, cdrom_locks[device], locks + 1);
-    regs->al = 1;
-    disk_ret(regs, DISK_RET_SUCCESS);
-}
-
-// unlock
-static void
-cdrom_134501(struct bregs *regs, u8 device)
+static int
+cdemu_read(struct disk_op_s *op)
 {
     u16 ebda_seg = get_ebda_seg();
-    u8 locks = GET_EBDA2(ebda_seg, cdrom_locks[device]);
-    if (locks == 0x00) {
-        regs->al = 0;
-        disk_ret(regs, DISK_RET_ENOTLOCKED);
-        return;
-    }
-    locks--;
-    SET_EBDA2(ebda_seg, cdrom_locks[device], locks);
-    regs->al = (locks ? 1 : 0);
-    disk_ret(regs, DISK_RET_SUCCESS);
-}
-
-// status
-static void
-cdrom_134502(struct bregs *regs, u8 device)
-{
-    u8 locks = GET_EBDA(cdrom_locks[device]);
-    regs->al = (locks ? 1 : 0);
-    disk_ret(regs, DISK_RET_SUCCESS);
-}
-
-static void
-cdrom_1345XX(struct bregs *regs, u8 device)
-{
-    disk_ret(regs, DISK_RET_EPARAM);
-}
-
-// IBM/MS lock/unlock drive
-static void
-cdrom_1345(struct bregs *regs, u8 device)
-{
-    switch (regs->al) {
-    case 0x00: cdrom_134500(regs, device); break;
-    case 0x01: cdrom_134501(regs, device); break;
-    case 0x02: cdrom_134502(regs, device); break;
-    default:   cdrom_1345XX(regs, device); break;
+    struct drive_s *drive_g;
+    drive_g = GLOBALFLAT2GLOBAL(GET_EBDA2(ebda_seg, cdemu.emulated_drive_gf));
+    struct disk_op_s dop;
+    dop.drive_g = drive_g;
+    dop.command = op->command;
+    dop.lba = GET_EBDA2(ebda_seg, cdemu.ilba) + op->lba / 4;
+
+    int count = op->count;
+    op->count = 0;
+    u8 *cdbuf_fl = GET_GLOBAL(bounce_buf_fl);
+
+    if (op->lba & 3) {
+        // Partial read of first block.
+        dop.count = 1;
+        dop.buf_fl = cdbuf_fl;
+        int ret = process_op(&dop);
+        if (ret)
+            return ret;
+        u8 thiscount = 4 - (op->lba & 3);
+        if (thiscount > count)
+            thiscount = count;
+        count -= thiscount;
+        memcpy_fl(op->buf_fl, cdbuf_fl + (op->lba & 3) * 512, thiscount * 512);
+        op->buf_fl += thiscount * 512;
+        op->count += thiscount;
+        dop.lba++;
     }
-}
 
-// IBM/MS eject media
-static void
-cdrom_1346(struct bregs *regs, u8 device)
-{
-    u8 locks = GET_EBDA(cdrom_locks[device]);
-    if (locks != 0) {
-        disk_ret(regs, DISK_RET_ELOCKED);
-        return;
+    if (count > 3) {
+        // Read n number of regular blocks.
+        dop.count = count / 4;
+        dop.buf_fl = op->buf_fl;
+        int ret = process_op(&dop);
+        op->count += dop.count * 4;
+        if (ret)
+            return ret;
+        u8 thiscount = count & ~3;
+        count &= 3;
+        op->buf_fl += thiscount * 512;
+        dop.lba += thiscount / 4;
     }
 
-    // FIXME should handle 0x31 no media in device
-    // FIXME should handle 0xb5 valid request failed
-
-    // Call removable media eject
-    struct bregs br;
-    memset(&br, 0, sizeof(br));
-    br.ah = 0x52;
-    call16_int(0x15, &br);
-
-    if (br.ah || br.flags & F_CF) {
-        disk_ret(regs, DISK_RET_ELOCKED);
-        return;
+    if (count) {
+        // Partial read on last block.
+        dop.count = 1;
+        dop.buf_fl = cdbuf_fl;
+        int ret = process_op(&dop);
+        if (ret)
+            return ret;
+        u8 thiscount = count;
+        memcpy_fl(op->buf_fl, cdbuf_fl, thiscount * 512);
+        op->count += thiscount;
     }
-    disk_ret(regs, DISK_RET_SUCCESS);
-}
-
-// IBM/MS extended media change
-static void
-cdrom_1349(struct bregs *regs, u8 device)
-{
-    set_fail(regs);
-    // always send changed ??
-    regs->ah = DISK_RET_ECHANGED;
-}
 
-static void
-cdrom_ok(struct bregs *regs, u8 device)
-{
-    disk_ret(regs, DISK_RET_SUCCESS);
+    return DISK_RET_SUCCESS;
 }
 
-static void
-cdrom_wp(struct bregs *regs, u8 device)
+int
+process_cdemu_op(struct disk_op_s *op)
 {
-    disk_ret(regs, DISK_RET_EWRITEPROTECT);
-}
+    if (!CONFIG_CDROM_EMU)
+        return 0;
 
-void
-cdrom_13(struct bregs *regs, u8 device)
-{
-    //debug_stub(regs);
-
-    switch (regs->ah) {
-    case 0x15: cdrom_1315(regs, device); break;
-    case 0x45: cdrom_1345(regs, device); break;
-    case 0x46: cdrom_1346(regs, device); break;
-    case 0x49: cdrom_1349(regs, device); break;
-
-    // These functions are the same as for hard disks
-    case 0x01:
-    case 0x41:
-    case 0x42:
-    case 0x44:
-    case 0x47:
-    case 0x48:
-    case 0x4e:
-        disk_13(regs, device);
-        break;
-
-    // all these functions return SUCCESS
-    case 0x00: // disk controller reset
-    case 0x09: // initialize drive parameters
-    case 0x0c: // seek to specified cylinder
-    case 0x0d: // alternate disk reset
-    case 0x10: // check drive ready
-    case 0x11: // recalibrate
-    case 0x14: // controller internal diagnostic
-    case 0x16: // detect disk change
-        cdrom_ok(regs, device);
-        break;
-
-    // all these functions return disk write-protected
-    case 0x03: // write disk sectors
-    case 0x05: // format disk track
-    case 0x43: // IBM/MS extended write
-        cdrom_wp(regs, device);
-        break;
-
-    default:   disk_13XX(regs, device); break;
+    switch (op->command) {
+    case CMD_READ:
+        return cdemu_read(op);
+    case CMD_WRITE:
+    case CMD_FORMAT:
+        return DISK_RET_EWRITEPROTECT;
+    case CMD_VERIFY:
+    case CMD_RESET:
+    case CMD_SEEK:
+    case CMD_ISREADY:
+        return DISK_RET_SUCCESS;
+    default:
+        op->count = 0;
+        return DISK_RET_EPARAM;
     }
 }
 
-
-/****************************************************************
- * CD emulation
- ****************************************************************/
-
-// read disk drive parameters
-static void
-cdemu_1308(struct bregs *regs, u8 device)
-{
-    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;
-    regs->ch = nlc & 0xff;
-    regs->cl = ((nlc >> 2) & 0xc0) | (nlspt & 0x3f);
-    regs->dh = nlh;
-    // 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_EBDA2(ebda_seg, cdemu.media);
-    if (media <= 3)
-        regs->bl = media * 2;
-
-    regs->es = SEG_BIOS;
-    regs->di = (u32)&diskette_param_table2;
-
-    disk_ret(regs, DISK_RET_SUCCESS);
-}
-
 void
-cdemu_13(struct bregs *regs)
+cdemu_setup(void)
 {
-    //debug_stub(regs);
+    if (!CONFIG_CDROM_EMU)
+        return;
+    if (!CDCount)
+        return;
+    if (bounce_buf_init() < 0)
+        return;
 
-    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
-    case 0x02:
-    case 0x04:
-        disk_13(regs, device);
-        break;
-
-    // These functions are the same as standard CDROM.
-    case 0x00:
-    case 0x01:
-    case 0x03:
-    case 0x05:
-    case 0x09:
-    case 0x0c:
-    case 0x0d:
-    case 0x10:
-    case 0x11:
-    case 0x14:
-    case 0x15:
-    case 0x16:
-        cdrom_13(regs, device);
-        break;
-
-    case 0x08: cdemu_1308(regs, device); break;
-
-    default:   disk_13XX(regs, device); break;
+    struct drive_s *drive_g = malloc_fseg(sizeof(*drive_g));
+    if (!drive_g) {
+        warn_noalloc();
+        free(drive_g);
+        return;
     }
+    cdemu_drive_gf = drive_g;
+    memset(drive_g, 0, sizeof(*drive_g));
+    drive_g->type = DTYPE_CDEMU;
+    drive_g->blksize = DISK_SECTOR_SIZE;
+    drive_g->sectors = (u64)-1;
 }
 
 struct eltorito_s {
@@ -271,22 +152,28 @@ cdemu_134b(struct bregs *regs)
     u16 ebda_seg = get_ebda_seg();
     SET_INT13ET(regs, size, 0x13);
     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, emulated_drive
+                , GET_EBDA2(ebda_seg, cdemu.emulated_extdrive));
+    struct drive_s *drive_gf = GET_EBDA2(ebda_seg, cdemu.emulated_drive_gf);
+    u8 cntl_id = 0;
+    if (drive_gf)
+        cntl_id = GET_GLOBALFLAT(drive_gf->cntl_id);
+    SET_INT13ET(regs, controller_index, cntl_id / 2);
+    SET_INT13ET(regs, device_spec, cntl_id % 2);
     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));
+    SET_INT13ET(regs, cylinders, GET_EBDA2(ebda_seg, cdemu.lchs.cylinders));
+    SET_INT13ET(regs, sectors, GET_EBDA2(ebda_seg, cdemu.lchs.spt));
+    SET_INT13ET(regs, heads, GET_EBDA2(ebda_seg, cdemu.lchs.heads));
 
     // If we have to terminate emulation
     if (regs->al == 0x00) {
         // FIXME ElTorito Various. Should be handled accordingly to spec
         SET_EBDA2(ebda_seg, cdemu.active, 0x00); // bye bye
+
+        // XXX - update floppy/hd count.
     }
 
     disk_ret(regs, DISK_RET_SUCCESS);
@@ -297,80 +184,41 @@ cdemu_134b(struct bregs *regs)
  * CD booting
  ****************************************************************/
 
-// Request SENSE
 static int
-atapi_get_sense(int device, u8 *asc, u8 *ascq)
+atapi_is_ready(struct disk_op_s *op)
 {
-    u8 atacmd[12], buffer[18];
-    memset(atacmd, 0, sizeof(atacmd));
-    atacmd[0] = ATA_CMD_REQUEST_SENSE;
-    atacmd[4] = sizeof(buffer);
-    int ret = ata_cmd_packet(device, atacmd, sizeof(atacmd), sizeof(buffer)
-                             , MAKE_FLATPTR(GET_SEG(SS), buffer));
-    if (ret)
-        return ret;
-
-    *asc = buffer[12];
-    *ascq = buffer[13];
-
-    return 0;
-}
-
-// Request capacity
-static int
-atapi_read_capacity(int device, u32 *blksize, u32 *sectors)
-{
-    u8 packet[12], buf[8];
-    memset(packet, 0, sizeof(packet));
-    packet[0] = 0x25; /* READ CAPACITY */
-    int ret = ata_cmd_packet(device, packet, sizeof(packet), sizeof(buf)
-                             , MAKE_FLATPTR(GET_SEG(SS), buf));
-    if (ret)
-        return ret;
-
-    *blksize = (((u32)buf[4] << 24) | ((u32)buf[5] << 16)
-                | ((u32)buf[6] << 8) | ((u32)buf[7] << 0));
-    *sectors = (((u32)buf[0] << 24) | ((u32)buf[1] << 16)
-                | ((u32)buf[2] << 8) | ((u32)buf[3] << 0));
-
-    return 0;
-}
-
-static int
-atapi_is_ready(u16 device)
-{
-    dprintf(6, "atapi_is_ready (device=%d)\n", device);
+    dprintf(6, "atapi_is_ready (drive=%p)\n", op->drive_g);
 
     /* Retry READ CAPACITY for 5 seconds unless MEDIUM NOT PRESENT is
      * reported by the device.  If the device reports "IN PROGRESS",
      * 30 seconds is added. */
-    u32 blksize, sectors;
+    struct cdbres_read_capacity info;
     int in_progress = 0;
     u64 end = calc_future_tsc(5000);
     for (;;) {
-        if (rdtscll() > end) {
+        if (check_tsc(end)) {
             dprintf(1, "read capacity failed\n");
             return -1;
         }
 
-        int ret = atapi_read_capacity(device, &blksize, &sectors);
+        int ret = cdb_read_capacity(op, &info);
         if (!ret)
             // Success
             break;
 
-        u8 asc, ascq;
-        ret = atapi_get_sense(device, &asc, &ascq);
+        struct cdbres_request_sense sense;
+        ret = cdb_get_sense(op, &sense);
         if (ret)
             // Error - retry.
             continue;
 
         // Sense succeeded.
-        if (asc == 0x3a) { /* MEDIUM NOT PRESENT */
+        if (sense.asc == 0x3a) { /* MEDIUM NOT PRESENT */
             dprintf(1, "Device reports MEDIUM NOT PRESENT\n");
             return -1;
         }
 
-        if (asc == 0x04 && ascq == 0x01 && !in_progress) {
+        if (sense.asc == 0x04 && sense.ascq == 0x01 && !in_progress) {
             /* IN PROGRESS OF BECOMING READY */
             printf("Waiting for device to detect medium... ");
             /* Allow 30 seconds more */
@@ -379,7 +227,8 @@ atapi_is_ready(u16 device)
         }
     }
 
-    if (blksize != GET_GLOBAL(ATA.devices[device].blksize)) {
+    u32 blksize = ntohl(info.blksize), sectors = ntohl(info.sectors);
+    if (blksize != GET_GLOBAL(op->drive_g->blksize)) {
         printf("Unsupported sector size %u\n", blksize);
         return -1;
     }
@@ -390,34 +239,32 @@ atapi_is_ready(u16 device)
 }
 
 int
-cdrom_boot(int cdid)
+cdrom_boot(struct drive_s *drive_g)
 {
-    // Verify device is a cdrom.
-    if (cdid >= ATA.cdcount)
+    struct disk_op_s dop;
+    int cdid = getDriveId(EXTTYPE_CD, drive_g);
+    memset(&dop, 0, sizeof(dop));
+    dop.drive_g = drive_g;
+    if (!dop.drive_g || cdid < 0)
         return 1;
-    int driveid = GET_GLOBAL(ATA.idmap[1][cdid]);
-    if (GET_GLOBAL(ATA.devices[driveid].device) != ATA_DEVICE_CDROM)
-        return 2;
 
-    int ret = atapi_is_ready(driveid);
+    int ret = atapi_is_ready(&dop);
     if (ret)
         dprintf(1, "atapi_is_ready returned %d\n", ret);
 
     // Read the Boot Record Volume Descriptor
     u8 buffer[2048];
-    struct disk_op_s dop;
-    dop.driveid = driveid;
     dop.lba = 0x11;
     dop.count = 1;
     dop.buf_fl = MAKE_FLATPTR(GET_SEG(SS), buffer);
-    ret = cdrom_read(&dop);
+    ret = cdb_read(&dop);
     if (ret)
         return 3;
 
     // Validity checks
     if (buffer[0])
         return 4;
-    if (!streq((char*)&buffer[1], "CD001\001EL TORITO SPECIFICATION"))
+    if (strcmp((char*)&buffer[1], "CD001\001EL TORITO SPECIFICATION") != 0)
         return 5;
 
     // ok, now we calculate the Boot catalog address
@@ -425,7 +272,8 @@ cdrom_boot(int cdid)
 
     // And we read the Boot Catalog
     dop.lba = lba;
-    ret = cdrom_read(&dop);
+    dop.count = 1;
+    ret = cdb_read(&dop);
     if (ret)
         return 7;
 
@@ -447,8 +295,7 @@ cdrom_boot(int cdid)
     u8 media = buffer[0x21];
     SET_EBDA2(ebda_seg, cdemu.media, media);
 
-    SET_EBDA2(ebda_seg, cdemu.controller_index, driveid/2);
-    SET_EBDA2(ebda_seg, cdemu.device_spec, driveid%2);
+    SET_EBDA2(ebda_seg, cdemu.emulated_drive_gf, dop.drive_g);
 
     u16 boot_segment = *(u16*)&buffer[0x22];
     if (!boot_segment)
@@ -463,50 +310,51 @@ cdrom_boot(int cdid)
     SET_EBDA2(ebda_seg, cdemu.ilba, lba);
 
     // And we read the image in memory
-    dop.lba = lba * 4;
-    dop.count = nbsectors;
+    dop.lba = lba;
+    dop.count = DIV_ROUND_UP(nbsectors, 4);
     dop.buf_fl = MAKE_FLATPTR(boot_segment, 0);
-    ret = cdrom_read_512(&dop);
+    ret = cdb_read(&dop);
     if (ret)
         return 12;
 
     if (media == 0) {
         // No emulation requested - return success.
-        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0xE0 + cdid);
+        SET_EBDA2(ebda_seg, cdemu.emulated_extdrive, EXTSTART_CD + cdid);
         return 0;
     }
 
     // Emulation of a floppy/harddisk requested
-    if (! CONFIG_CDROM_EMU)
+    if (! CONFIG_CDROM_EMU || !cdemu_drive_gf)
         return 13;
 
     // Set emulated drive id and increase bios installed hardware
     // number of devices
     if (media < 4) {
         // Floppy emulation
-        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0x00);
+        SET_EBDA2(ebda_seg, cdemu.emulated_extdrive, 0x00);
+        // XXX - get and set actual floppy count.
         SETBITS_BDA(equipment_list_flags, 0x41);
 
         switch (media) {
         case 0x01:  // 1.2M floppy
-            SET_EBDA2(ebda_seg, cdemu.spt, 15);
-            SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
-            SET_EBDA2(ebda_seg, cdemu.heads, 2);
+            SET_EBDA2(ebda_seg, cdemu.lchs.spt, 15);
+            SET_EBDA2(ebda_seg, cdemu.lchs.cylinders, 80);
+            SET_EBDA2(ebda_seg, cdemu.lchs.heads, 2);
             break;
         case 0x02:  // 1.44M floppy
-            SET_EBDA2(ebda_seg, cdemu.spt, 18);
-            SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
-            SET_EBDA2(ebda_seg, cdemu.heads, 2);
+            SET_EBDA2(ebda_seg, cdemu.lchs.spt, 18);
+            SET_EBDA2(ebda_seg, cdemu.lchs.cylinders, 80);
+            SET_EBDA2(ebda_seg, cdemu.lchs.heads, 2);
             break;
         case 0x03:  // 2.88M floppy
-            SET_EBDA2(ebda_seg, cdemu.spt, 36);
-            SET_EBDA2(ebda_seg, cdemu.cylinders, 80);
-            SET_EBDA2(ebda_seg, cdemu.heads, 2);
+            SET_EBDA2(ebda_seg, cdemu.lchs.spt, 36);
+            SET_EBDA2(ebda_seg, cdemu.lchs.cylinders, 80);
+            SET_EBDA2(ebda_seg, cdemu.lchs.heads, 2);
             break;
         }
     } else {
         // Harddrive emulation
-        SET_EBDA2(ebda_seg, cdemu.emulated_drive, 0x80);
+        SET_EBDA2(ebda_seg, cdemu.emulated_extdrive, 0x80);
         SET_BDA(hdcount, GET_BDA(hdcount) + 1);
 
         // Peak at partition table to get chs.
@@ -515,9 +363,10 @@ cdrom_boot(int cdid)
         u8 cyllow = GET_FARVAR(boot_segment, mbr->partitions[0].last.cyllow);
         u8 heads = GET_FARVAR(boot_segment, mbr->partitions[0].last.heads);
 
-        SET_EBDA2(ebda_seg, cdemu.spt, sptcyl & 0x3f);
-        SET_EBDA2(ebda_seg, cdemu.cylinders, ((sptcyl<<2)&0x300) + cyllow + 1);
-        SET_EBDA2(ebda_seg, cdemu.heads, heads + 1);
+        SET_EBDA2(ebda_seg, cdemu.lchs.spt, sptcyl & 0x3f);
+        SET_EBDA2(ebda_seg, cdemu.lchs.cylinders
+                  , ((sptcyl<<2)&0x300) + cyllow + 1);
+        SET_EBDA2(ebda_seg, cdemu.lchs.heads, heads + 1);
     }
 
     // everything is ok, so from now on, the emulation is active