| // Support for booting from cdroms (the "El Torito" spec). |
| // |
| // 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. |
| |
| #include "disk.h" // cdrom_13 |
| #include "util.h" // memset |
| #include "bregs.h" // struct bregs |
| #include "biosvar.h" // GET_GLOBAL |
| #include "ata.h" // ATA_CMD_REQUEST_SENSE |
| #include "blockcmd.h" // CDB_CMD_REQUEST_SENSE |
| |
| // Locks for removable devices |
| u8 CDRom_locks[CONFIG_MAX_EXTDRIVE] VARLOW; |
| |
| |
| /**************************************************************** |
| * CD emulation |
| ****************************************************************/ |
| |
| struct cdemu_s CDEmu VARLOW; |
| struct drive_s *cdemu_drive_gf VAR16VISIBLE; |
| |
| static int |
| cdemu_read(struct disk_op_s *op) |
| { |
| struct drive_s *drive_g; |
| drive_g = GLOBALFLAT2GLOBAL(GET_LOW(CDEmu.emulated_drive_gf)); |
| struct disk_op_s dop; |
| dop.drive_g = drive_g; |
| 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 |
| process_cdemu_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; |
| case CMD_VERIFY: |
| case CMD_RESET: |
| case CMD_SEEK: |
| case CMD_ISREADY: |
| return DISK_RET_SUCCESS; |
| default: |
| op->count = 0; |
| return DISK_RET_EPARAM; |
| } |
| } |
| |
| void |
| cdemu_setup(void) |
| { |
| if (!CONFIG_CDROM_EMU) |
| return; |
| if (!CDCount) |
| return; |
| if (bounce_buf_init() < 0) |
| return; |
| |
| 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 { |
| u8 size; |
| u8 media; |
| u8 emulated_drive; |
| u8 controller_index; |
| u32 ilba; |
| u16 device_spec; |
| u16 buffer_segment; |
| u16 load_segment; |
| u16 sector_count; |
| u8 cylinders; |
| u8 sectors; |
| u8 heads; |
| }; |
| |
| #define SET_INT13ET(regs,var,val) \ |
| SET_FARVAR((regs)->ds, ((struct eltorito_s*)((regs)->si+0))->var, (val)) |
| |
| // ElTorito - Terminate disk emu |
| void |
| cdemu_134b(struct bregs *regs) |
| { |
| // FIXME ElTorito Hardcoded |
| SET_INT13ET(regs, size, 0x13); |
| SET_INT13ET(regs, media, GET_LOW(CDEmu.media)); |
| SET_INT13ET(regs, emulated_drive, GET_LOW(CDEmu.emulated_extdrive)); |
| struct drive_s *drive_gf = GET_LOW(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_LOW(CDEmu.ilba)); |
| SET_INT13ET(regs, buffer_segment, GET_LOW(CDEmu.buffer_segment)); |
| SET_INT13ET(regs, load_segment, GET_LOW(CDEmu.load_segment)); |
| SET_INT13ET(regs, sector_count, GET_LOW(CDEmu.sector_count)); |
| SET_INT13ET(regs, cylinders, GET_LOW(CDEmu.lchs.cylinders)); |
| SET_INT13ET(regs, sectors, GET_LOW(CDEmu.lchs.spt)); |
| SET_INT13ET(regs, heads, GET_LOW(CDEmu.lchs.heads)); |
| |
| // If we have to terminate emulation |
| if (regs->al == 0x00) { |
| // FIXME ElTorito Various. Should be handled accordingly to spec |
| SET_LOW(CDEmu.active, 0x00); // bye bye |
| |
| // XXX - update floppy/hd count. |
| } |
| |
| disk_ret(regs, DISK_RET_SUCCESS); |
| } |
| |
| |
| /**************************************************************** |
| * CD booting |
| ****************************************************************/ |
| |
| int |
| cdrom_boot(struct drive_s *drive_g) |
| { |
| ASSERT32FLAT(); |
| 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 ret = scsi_is_ready(&dop); |
| if (ret) |
| dprintf(1, "scsi_is_ready returned %d\n", ret); |
| |
| // Read the Boot Record Volume Descriptor |
| u8 buffer[CDROM_SECTOR_SIZE]; |
| dop.lba = 0x11; |
| dop.count = 1; |
| dop.buf_fl = buffer; |
| ret = cdb_read(&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 = cdb_read(&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 |
| |
| u8 media = buffer[0x21]; |
| CDEmu.media = media; |
| |
| CDEmu.emulated_drive_gf = dop.drive_g; |
| |
| 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; |
| |
| // And we read the image in memory |
| dop.lba = lba; |
| dop.count = DIV_ROUND_UP(nbsectors, 4); |
| dop.buf_fl = MAKE_FLATPTR(boot_segment, 0); |
| ret = cdb_read(&dop); |
| if (ret) |
| return 12; |
| |
| if (media == 0) { |
| // No emulation requested - return success. |
| CDEmu.emulated_extdrive = 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_extdrive = 0x00; |
| // XXX - get and set actual floppy count. |
| set_equipment_flags(0x41, 0x41); |
| |
| switch (media) { |
| case 0x01: // 1.2M floppy |
| CDEmu.lchs.spt = 15; |
| CDEmu.lchs.cylinders = 80; |
| CDEmu.lchs.heads = 2; |
| break; |
| case 0x02: // 1.44M floppy |
| CDEmu.lchs.spt = 18; |
| CDEmu.lchs.cylinders = 80; |
| CDEmu.lchs.heads = 2; |
| break; |
| case 0x03: // 2.88M floppy |
| CDEmu.lchs.spt = 36; |
| CDEmu.lchs.cylinders = 80; |
| CDEmu.lchs.heads = 2; |
| break; |
| } |
| } else { |
| // Harddrive emulation |
| CDEmu.emulated_extdrive = 0x80; |
| SET_BDA(hdcount, GET_BDA(hdcount) + 1); |
| |
| // Peak at partition table to get chs. |
| struct mbr_s *mbr = (void*)0; |
| u8 sptcyl = GET_FARVAR(boot_segment, mbr->partitions[0].last.sptcyl); |
| u8 cyllow = GET_FARVAR(boot_segment, mbr->partitions[0].last.cyllow); |
| u8 heads = GET_FARVAR(boot_segment, mbr->partitions[0].last.heads); |
| |
| CDEmu.lchs.spt = sptcyl & 0x3f; |
| CDEmu.lchs.cylinders = ((sptcyl<<2)&0x300) + cyllow + 1; |
| CDEmu.lchs.heads = heads + 1; |
| } |
| |
| // everything is ok, so from now on, the emulation is active |
| CDEmu.active = 0x01; |
| dprintf(6, "cdemu media=%d\n", media); |
| |
| return 0; |
| } |