// INT 13h Fixed Disk Services Entry Point
void VISIBLE16
handle_13(struct bregs *regs)
{
debug_enter(regs, DEBUG_HDL_13);
u8 extdrive = regs->dl;
if (CONFIG_CDROM_EMU) {
if (regs->ah == 0x4b) {
cdemu_134b(regs);
return;
}
u16 ebda_seg = get_ebda_seg();
if (GET_EBDA2(ebda_seg, cdemu.active)) {
u8 emudrive = GET_EBDA2(ebda_seg, cdemu.emulated_extdrive);
if (extdrive == emudrive) {
// Access to an emulated drive.
struct drive_s *cdemu = GET_GLOBAL(cdemu_drive);
if (regs->ah > 0x16) {
// Only old-style commands supported.
disk_13XX(regs, cdemu);
return;
}
disk_13(regs, cdemu);
return;
}
if (extdrive < EXTSTART_CD && ((emudrive ^ extdrive) & 0x80) == 0)
// Adjust id to make room for emulated drive.
extdrive--;
}
}
handle_legacy_disk(regs, extdrive);
}
// read disk drive parameters
static void noinline
disk_1308(struct bregs *regs, struct drive_s *drive_g)
{
u16 ebda_seg = get_ebda_seg();
// Get logical geometry from table
u16 nlc, nlh, nlspt;
fillLCHS(drive_g, &nlc, &nlh, &nlspt);
nlc--;
nlh--;
u8 count;
if (regs->dl < EXTSTART_HD) {
// Floppy
count = GET_GLOBAL(FloppyCount);
if (CONFIG_CDROM_EMU
&& drive_g == GLOBALFLAT2GLOBAL(GET_GLOBAL(cdemu_drive_gf)))
regs->bx = GET_EBDA2(ebda_seg, cdemu.media) * 2;
else
regs->bx = GET_GLOBAL(drive_g->floppy_type);
// set es & di to point to 11 byte diskette param table in ROM
regs->es = SEG_BIOS;
regs->di = (u32)&diskette_param_table2;
} else if (regs->dl < EXTSTART_CD) {
// Hard drive
count = GET_BDA(hdcount);
nlc--; // last sector reserved
} else {
// Not supported on CDROM
disk_ret(regs, DISK_RET_EPARAM);
return;
}
if (CONFIG_CDROM_EMU && GET_EBDA2(ebda_seg, cdemu.active)) {
u8 emudrive = GET_EBDA2(ebda_seg, cdemu.emulated_extdrive);
if (((emudrive ^ regs->dl) & 0x80) == 0)
// Note extra drive due to emulation.
count++;
if (regs->dl < EXTSTART_HD && count > 2)
// Max of two floppy drives.
count = 2;
}
regs->al = 0;
regs->ch = nlc & 0xff;
regs->cl = ((nlc >> 2) & 0xc0) | (nlspt & 0x3f);
regs->dh = nlh;
disk_ret(regs, DISK_RET_SUCCESS);
regs->dl = count;
}
// lock
static void
disk_134500(struct bregs *regs, struct drive_s *drive_g)
{
u16 ebda_seg = get_ebda_seg();
int cdid = regs->dl - EXTSTART_CD;
u8 locks = GET_EBDA2(ebda_seg, cdrom_locks[cdid]);
if (locks == 0xff) {
regs->al = 1;
disk_ret(regs, DISK_RET_ETOOMANYLOCKS);
return;
}
SET_EBDA2(ebda_seg, cdrom_locks[cdid], locks + 1);
regs->al = 1;
disk_ret(regs, DISK_RET_SUCCESS);
}
// unlock
static void
disk_134501(struct bregs *regs, struct drive_s *drive_g)
{
u16 ebda_seg = get_ebda_seg();
int cdid = regs->dl - EXTSTART_CD;
u8 locks = GET_EBDA2(ebda_seg, cdrom_locks[cdid]);
if (locks == 0x00) {
regs->al = 0;
disk_ret(regs, DISK_RET_ENOTLOCKED);
return;
}
locks--;
SET_EBDA2(ebda_seg, cdrom_locks[cdid], locks);
regs->al = (locks ? 1 : 0);
disk_ret(regs, DISK_RET_SUCCESS);
}
static void
fillLCHS(struct drive_s *drive_g, u16 *nlc, u16 *nlh, u16 *nlspt)
{
if (CONFIG_CDROM_EMU && drive_g == GET_GLOBAL(cdemu_drive)) {
// Emulated drive - get info from ebda. (It's not possible to
// populate the geometry directly in the driveid because the
// geometry is only known after the bios segment is made
// read-only).
u16 ebda_seg = get_ebda_seg();
*nlc = GET_EBDA2(ebda_seg, cdemu.lchs.cylinders);
*nlh = GET_EBDA2(ebda_seg, cdemu.lchs.heads);
*nlspt = GET_EBDA2(ebda_seg, cdemu.lchs.spt);
return;
}
*nlc = GET_GLOBAL(drive_g->lchs.cylinders);
*nlh = GET_GLOBAL(drive_g->lchs.heads);
*nlspt = GET_GLOBAL(drive_g->lchs.spt);
}
// IBM/MS get drive parameters
static void
disk_1348(struct bregs *regs, struct drive_s *drive_g)
{
u16 size = GET_INT13DPT(regs, size);
// Buffer is too small
if (size < 26) {
disk_ret(regs, DISK_RET_EPARAM);
return;
}
// EDD 1.x
u8 type = GET_GLOBAL(drive_g->type);
u16 npc = GET_GLOBAL(drive_g->pchs.cylinders);
u16 nph = GET_GLOBAL(drive_g->pchs.heads);
u16 npspt = GET_GLOBAL(drive_g->pchs.spt);
u64 lba = GET_GLOBAL(drive_g->sectors);
u16 blksize = GET_GLOBAL(drive_g->blksize);
dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
, size, type, npc, nph, npspt, (u32)lba, blksize);
SET_INT13DPT(regs, size, 26);
if (type == DTYPE_ATAPI) {
// 0x74 = removable, media change, lockable, max values
SET_INT13DPT(regs, infos, 0x74);
SET_INT13DPT(regs, cylinders, 0xffffffff);
SET_INT13DPT(regs, heads, 0xffffffff);
SET_INT13DPT(regs, spt, 0xffffffff);
SET_INT13DPT(regs, sector_count, (u64)-1);
} else {
if (lba > (u64)npspt*nph*0x3fff) {
SET_INT13DPT(regs, infos, 0x00); // geometry is invalid
SET_INT13DPT(regs, cylinders, 0x3fff);
} else {
SET_INT13DPT(regs, infos, 0x02); // geometry is valid
SET_INT13DPT(regs, cylinders, (u32)npc);
}
SET_INT13DPT(regs, heads, (u32)nph);
SET_INT13DPT(regs, spt, (u32)npspt);
SET_INT13DPT(regs, sector_count, lba);
}
SET_INT13DPT(regs, blksize, blksize);
if (size < 30 || (type != DTYPE_ATA && type != DTYPE_ATAPI)) {
disk_ret(regs, DISK_RET_SUCCESS);
return;
}
// EDD 2.x
u16 ebda_seg = get_ebda_seg();
SET_INT13DPT(regs, size, 30);
SET_INT13DPT(regs, dpte_segment, ebda_seg);
SET_INT13DPT(regs, dpte_offset
, offsetof(struct extended_bios_data_area_s, dpte));
// Fill in dpte
u8 ataid = GET_GLOBAL(drive_g->cntl_id);
u8 channel = ataid / 2;
u8 slave = ataid % 2;
u16 iobase1 = GET_GLOBAL(ATA_channels[channel].iobase1);
u16 iobase2 = GET_GLOBAL(ATA_channels[channel].iobase2);
u8 irq = GET_GLOBAL(ATA_channels[channel].irq);
u16 options = 0;
if (type == DTYPE_ATA) {
u8 translation = GET_GLOBAL(drive_g->translation);
if (translation != TRANSLATION_NONE) {
options |= 1<<3; // CHS translation
if (translation == TRANSLATION_LBA)
options |= 1<<9;
if (translation == TRANSLATION_RECHS)
options |= 3<<9;
}
} else {
// ATAPI
options |= 1<<5; // removable device
options |= 1<<6; // atapi device
}
options |= 1<<4; // lba translation
if (CONFIG_ATA_PIO32)
options |= 1<<7;
SET_EBDA2(ebda_seg, dpte.iobase1, iobase1);
SET_EBDA2(ebda_seg, dpte.iobase2, iobase2 + ATA_CB_DC);
SET_EBDA2(ebda_seg, dpte.prefix, ((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0)
| ATA_CB_DH_LBA));
SET_EBDA2(ebda_seg, dpte.unused, 0xcb);
SET_EBDA2(ebda_seg, dpte.irq, irq);
SET_EBDA2(ebda_seg, dpte.blkcount, 1);
SET_EBDA2(ebda_seg, dpte.dma, 0);
SET_EBDA2(ebda_seg, dpte.pio, 0);
SET_EBDA2(ebda_seg, dpte.options, options);
SET_EBDA2(ebda_seg, dpte.reserved, 0);
SET_EBDA2(ebda_seg, dpte.revision, 0x11);
u8 sum = checksum_far(
ebda_seg, (void*)offsetof(struct extended_bios_data_area_s, dpte), 15);
SET_EBDA2(ebda_seg, dpte.checksum, -sum);
if (size < 66) {
disk_ret(regs, DISK_RET_SUCCESS);
return;
}
// EDD 3.x
SET_INT13DPT(regs, key, 0xbedd);
SET_INT13DPT(regs, dpi_length, 36);
SET_INT13DPT(regs, reserved1, 0);
SET_INT13DPT(regs, reserved2, 0);
int bdf = GET_GLOBAL(ATA_channels[channel].pci_bdf);
if (bdf != -1) {
SET_INT13DPT(regs, host_bus[0], 'P');
SET_INT13DPT(regs, host_bus[1], 'C');
SET_INT13DPT(regs, host_bus[2], 'I');
SET_INT13DPT(regs, host_bus[3], 0);
u32 path = (pci_bdf_to_bus(bdf) | (pci_bdf_to_dev(bdf) << 8)
| (pci_bdf_to_fn(bdf) << 16));
SET_INT13DPT(regs, iface_path, path);
} else {
// ISA
SET_INT13DPT(regs, host_bus[0], 'I');
SET_INT13DPT(regs, host_bus[1], 'S');
SET_INT13DPT(regs, host_bus[2], 'A');
SET_INT13DPT(regs, host_bus[3], 0);
SET_INT13DPT(regs, iface_path, iobase1);
}
SET_INT13DPT(regs, iface_type[0], 'A');
SET_INT13DPT(regs, iface_type[1], 'T');
SET_INT13DPT(regs, iface_type[2], 'A');
SET_INT13DPT(regs, iface_type[3], 0);
SET_INT13DPT(regs, iface_type[4], 0);
SET_INT13DPT(regs, iface_type[5], 0);
SET_INT13DPT(regs, iface_type[6], 0);
SET_INT13DPT(regs, iface_type[7], 0);
SET_INT13DPT(regs, device_path, slave);
SET_INT13DPT(regs, checksum
, -checksum_far(regs->ds, (void*)(regs->si+30), 35));
disk_ret(regs, DISK_RET_SUCCESS);
}
// IBM/MS get drive parameters
static void
disk_1348(struct bregs *regs, struct drive_s *drive_g)
{
u16 size = GET_INT13DPT(regs, size);
u16 t13 = size == 74;
// Buffer is too small
if (size < 26) {
disk_ret(regs, DISK_RET_EPARAM);
return;
}
// EDD 1.x
u8 type = GET_GLOBAL(drive_g->type);
u16 npc = GET_GLOBAL(drive_g->pchs.cylinders);
u16 nph = GET_GLOBAL(drive_g->pchs.heads);
u16 npspt = GET_GLOBAL(drive_g->pchs.spt);
u64 lba = GET_GLOBAL(drive_g->sectors);
u16 blksize = GET_GLOBAL(drive_g->blksize);
dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n"
, size, type, npc, nph, npspt, (u32)lba, blksize);
SET_INT13DPT(regs, size, 26);
if (type == DTYPE_ATAPI) {
// 0x74 = removable, media change, lockable, max values
SET_INT13DPT(regs, infos, 0x74);
SET_INT13DPT(regs, cylinders, 0xffffffff);
SET_INT13DPT(regs, heads, 0xffffffff);
SET_INT13DPT(regs, spt, 0xffffffff);
SET_INT13DPT(regs, sector_count, (u64)-1);
} else {
if (lba > (u64)npspt*nph*0x3fff) {
SET_INT13DPT(regs, infos, 0x00); // geometry is invalid
SET_INT13DPT(regs, cylinders, 0x3fff);
} else {
SET_INT13DPT(regs, infos, 0x02); // geometry is valid
SET_INT13DPT(regs, cylinders, (u32)npc);
}
SET_INT13DPT(regs, heads, (u32)nph);
SET_INT13DPT(regs, spt, (u32)npspt);
SET_INT13DPT(regs, sector_count, lba);
}
SET_INT13DPT(regs, blksize, blksize);
if (size < 30 ||
(type != DTYPE_ATA && type != DTYPE_ATAPI &&
type != DTYPE_VIRTIO_BLK && type != DTYPE_VIRTIO_SCSI)) {
disk_ret(regs, DISK_RET_SUCCESS);
return;
}
// EDD 2.x
int bdf;
u16 iobase1 = 0;
u64 device_path = 0;
u8 channel = 0;
SET_INT13DPT(regs, size, 30);
if (type == DTYPE_ATA || type == DTYPE_ATAPI) {
u16 ebda_seg = get_ebda_seg();
SET_INT13DPT(regs, dpte_segment, ebda_seg);
SET_INT13DPT(regs, dpte_offset
, offsetof(struct extended_bios_data_area_s, dpte));
// Fill in dpte
struct atadrive_s *adrive_g = container_of(
drive_g, struct atadrive_s, drive);
struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf);
u8 slave = GET_GLOBAL(adrive_g->slave);
u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2);
u8 irq = GET_GLOBALFLAT(chan_gf->irq);
iobase1 = GET_GLOBALFLAT(chan_gf->iobase1);
bdf = GET_GLOBALFLAT(chan_gf->pci_bdf);
device_path = slave;
channel = GET_GLOBALFLAT(chan_gf->chanid);
u16 options = 0;
if (type == DTYPE_ATA) {
u8 translation = GET_GLOBAL(drive_g->translation);
if (translation != TRANSLATION_NONE) {
options |= 1<<3; // CHS translation
if (translation == TRANSLATION_LBA)
options |= 1<<9;
if (translation == TRANSLATION_RECHS)
options |= 3<<9;
}
} else {
// ATAPI
options |= 1<<5; // removable device
options |= 1<<6; // atapi device
}
options |= 1<<4; // lba translation
if (CONFIG_ATA_PIO32)
options |= 1<<7;
SET_EBDA2(ebda_seg, dpte.iobase1, iobase1);
SET_EBDA2(ebda_seg, dpte.iobase2, iobase2 + ATA_CB_DC);
SET_EBDA2(ebda_seg, dpte.prefix, ((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0)
| ATA_CB_DH_LBA));
SET_EBDA2(ebda_seg, dpte.unused, 0xcb);
SET_EBDA2(ebda_seg, dpte.irq, irq);
SET_EBDA2(ebda_seg, dpte.blkcount, 1);
SET_EBDA2(ebda_seg, dpte.dma, 0);
SET_EBDA2(ebda_seg, dpte.pio, 0);
SET_EBDA2(ebda_seg, dpte.options, options);
SET_EBDA2(ebda_seg, dpte.reserved, 0);
SET_EBDA2(ebda_seg, dpte.revision, 0x11);
u8 sum = checksum_far(
ebda_seg, (void*)offsetof(struct extended_bios_data_area_s, dpte), 15);
SET_EBDA2(ebda_seg, dpte.checksum, -sum);
} else {
