// Support for booting from cdroms (the "El Torito" spec). // // Copyright (C) 2008,2009 Kevin O'Connor // Copyright (C) 2002 MandrakeSoft S.A. // // This file may be distributed under the terms of the GNU LGPLv3 license. #include "biosvar.h" // GET_GLOBAL #include "block.h" // struct drive_s #include "bregs.h" // struct bregs #include "hw/ata.h" // ATA_CMD_REQUEST_SENSE #include "hw/blockcmd.h" // CDB_CMD_REQUEST_SENSE #include "malloc.h" // free #include "output.h" // dprintf #include "std/disk.h" // DISK_RET_SUCCESS #include "string.h" // memset #include "util.h" // cdrom_prepboot #include "tcgbios.h" // tpm_* /**************************************************************** * CD emulation ****************************************************************/ struct eltorito_s CDEmu VARLOW = { .size=sizeof(CDEmu) }; struct drive_s *emulated_drive_gf VARLOW; struct drive_s *cdemu_drive_gf VARFSEG; static int cdemu_read(struct disk_op_s *op) { struct drive_s *drive_gf = GET_LOW(emulated_drive_gf); struct disk_op_s dop; dop.drive_fl = drive_gf; dop.command = op->command; dop.lba = GET_LOW(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++; } 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; } 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; } return DISK_RET_SUCCESS; } int cdemu_process_op(struct disk_op_s *op) { if (!CONFIG_CDROM_EMU) return 0; switch (op->command) { case CMD_READ: return cdemu_read(op); case CMD_WRITE: case CMD_FORMAT: return DISK_RET_EWRITEPROTECT; default: return default_process_op(op); } } void cdrom_prepboot(void) { if (!CONFIG_CDROM_EMU) return; if (!CDCount) return; if (create_bounce_buf() < 0) return; struct drive_s *drive = malloc_fseg(sizeof(*drive)); if (!drive) { warn_noalloc(); return; } cdemu_drive_gf = drive; memset(drive, 0, sizeof(*drive)); drive->type = DTYPE_CDEMU; drive->blksize = DISK_SECTOR_SIZE; drive->sectors = (u64)-1; } /**************************************************************** * CD booting ****************************************************************/ int cdrom_boot(struct drive_s *drive) { ASSERT32FLAT(); struct disk_op_s dop; int cdid = getDriveId(EXTTYPE_CD, drive); memset(&dop, 0, sizeof(dop)); dop.drive_fl = drive; if (!dop.drive_fl || cdid < 0) return 1; int ret = scsi_is_ready(&dop); if (ret) dprintf(5, "scsi_is_ready returned %d\n", ret); // Read the Boot Record Volume Descriptor u8 buffer[CDROM_SECTOR_SIZE]; dop.command = CMD_READ; dop.lba = 0x11; dop.count = 1; dop.buf_fl = buffer; ret = process_op(&dop); if (ret) return 3; // Validity checks if (buffer[0]) return 4; if (strcmp((char*)&buffer[1], "CD001\001EL TORITO SPECIFICATION") != 0) return 5; // ok, now we calculate the Boot catalog address u32 lba = *(u32*)&buffer[0x47]; // And we read the Boot Catalog dop.lba = lba; dop.count = 1; ret = process_op(&dop); if (ret) return 7; // Validation entry if (buffer[0x00] != 0x01) return 8; // Header if (buffer[0x01] != 0x00) return 9; // Platform if (buffer[0x1E] != 0x55) return 10; // key 1 if (buffer[0x1F] != 0xAA) return 10; // key 2 // Initial/Default Entry if (buffer[0x20] != 0x88) return 11; // Bootable /* measure 2048 bytes (one sector) */ tpm_add_cdrom_catalog(MAKE_FLATPTR(GET_SEG(SS), buffer), sizeof(buffer)); // Fill in el-torito cdrom emulation fields. emulated_drive_gf = drive; u8 media = buffer[0x21]; u16 boot_segment = *(u16*)&buffer[0x22]; if (!boot_segment) boot_segment = 0x07C0; CDEmu.load_segment = boot_segment; CDEmu.buffer_segment = 0x0000; u16 nbsectors = *(u16*)&buffer[0x26]; CDEmu.sector_count = nbsectors; lba = *(u32*)&buffer[0x28]; CDEmu.ilba = lba; CDEmu.controller_index = drive->cntl_id / 2; CDEmu.device_spec = drive->cntl_id % 2; // And we read the image in memory nbsectors = DIV_ROUND_UP(nbsectors, 4); dop.lba = lba; dop.buf_fl = MAKE_FLATPTR(boot_segment, 0); while (nbsectors) { int count = nbsectors; if (count > 64*1024/CDROM_SECTOR_SIZE) count = 64*1024/CDROM_SECTOR_SIZE; dop.count = count; ret = process_op(&dop); if (ret) return 12; nbsectors -= count; dop.lba += count; dop.buf_fl += count*CDROM_SECTOR_SIZE; } if (media == 0) { // No emulation requested - return success. CDEmu.emulated_drive = EXTSTART_CD + cdid; return 0; } // Emulation of a floppy/harddisk requested 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 CDEmu.emulated_drive = 0x00; // XXX - get and set actual floppy count. set_equipment_flags(0x41, 0x41); switch (media) { case 0x01: // 1.2M floppy CDEmu.chs.sptcyl = 15; CDEmu.chs.cyllow = 79; CDEmu.chs.heads = 1; break; case 0x02: // 1.44M floppy CDEmu.chs.sptcyl = 18; CDEmu.chs.cyllow = 79; CDEmu.chs.heads = 1; break; case 0x03: // 2.88M floppy CDEmu.chs.sptcyl = 36; CDEmu.chs.cyllow = 79; CDEmu.chs.heads = 1; break; } } else { // Harddrive emulation CDEmu.emulated_drive = 0x80; SET_BDA(hdcount, GET_BDA(hdcount) + 1); // Peak at partition table to get chs. struct mbr_s *mbr = MAKE_FLATPTR(boot_segment, 0); CDEmu.chs = mbr->partitions[0].last; } // everything is ok, so from now on, the emulation is active CDEmu.media = media; dprintf(6, "cdemu media=%d\n", media); return 0; } // check if media is present and the drive is bootable. // in case it is return the volume label. char* cdrom_media_info(struct drive_s *drive) { ASSERT32FLAT(); struct disk_op_s dop; memset(&dop, 0, sizeof(dop)); dop.drive_fl = drive; int ret = scsi_is_ready(&dop); if (ret) return NULL; // Read the Boot Record Volume Descriptor u8 buffer[CDROM_SECTOR_SIZE]; dop.command = CMD_READ; dop.lba = 0x11; dop.count = 1; dop.buf_fl = buffer; ret = process_op(&dop); if (ret) return NULL; // Is it bootable? if (buffer[0]) return NULL; if (strcmp((char*)&buffer[1], "CD001\001EL TORITO SPECIFICATION") != 0) return NULL; // Read the Primary Volume Descriptor dop.command = CMD_READ; dop.lba = 0x10; dop.count = 1; dop.buf_fl = buffer; ret = process_op(&dop); if (ret) return NULL; // Read volume id, trim trailing spaces char *volume = znprintf(30, "%s", buffer + 40); nullTrailingSpace(volume); return volume; }