"use strict"; /** @param {number=} length */ function hex_dump(buffer, length) { var result = []; length = length || buffer.byteLength; var addr = 0; var line, byt; for(var i = 0; i < length >> 4; i++) { line = h(addr + (i << 4), 5) + " "; for(var j = 0; j < 0x10; j++) { byt = buffer[addr + (i << 4) + j]; line += h(byt, 2) + " "; } line += " "; for(j = 0; j < 0x10; j++) { byt = buffer[addr + (i << 4) + j]; line += (byt < 33 || byt > 126) ? "." : String.fromCharCode(byt); } result.push(line); } return "\n" + result.join("\n"); } /** @const */ var CDROM_SECTOR_SIZE = 2048; /** @const */ var HD_SECTOR_SIZE = 512; /** * @constructor * @param {CPU} cpu * @param {boolean} is_cd * @param {number} nr * @param {BusConnector} bus * */ function IDEDevice(cpu, master_buffer, slave_buffer, is_cd, nr, bus) { this.master = new IDEInterface(this, cpu, master_buffer, is_cd, nr, 0, bus); this.slave = new IDEInterface(this, cpu, slave_buffer, false, nr, 1, bus); this.current_interface = this.master; this.cpu = cpu; // gets set via PCI in seabios, likely doesn't matter if(nr === 0) { this.ata_port = 0x1F0; this.irq = 14; this.pci_id = 0x1E << 3; } else if(nr === 1) { this.ata_port = 0x170; this.irq = 15; this.pci_id = 0x1F << 3; } else { dbg_assert(false, "IDE device with nr " + nr + " ignored", LOG_DISK); } // alternate status, starting at 3f4/374 /** @type {number} */ this.ata_port_high = this.ata_port | 0x204; /** @type {number} */ this.master_port = 0xB400; this.pci_space = [ 0x86, 0x80, 0x10, 0x70, 0x05, 0x00, 0xA0, 0x02, 0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0 | 1, 0, 0x00, 0x00, 0 | 1, 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // second device 0x00, 0x00, 0x00, 0x00, // second device this.master_port & 0xFF | 1, this.master_port >> 8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x10, 0xD4, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, this.irq, 0x01, 0x00, 0x00, // 0x40 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ]; this.pci_bars = [ { size: 8, }, { size: 4, }, undefined, undefined, { size: 0x10, }, ]; this.name = "ide" + nr; /** @type {number} */ this.device_control = 2; // status cpu.io.register_read(this.ata_port | 7, this, function() { dbg_log("lower irq", LOG_DISK); this.cpu.device_lower_irq(this.irq); return this.read_status(); }); cpu.io.register_read(this.ata_port_high | 2, this, this.read_status); cpu.io.register_write(this.ata_port_high | 2, this, this.write_control); cpu.io.register_read(this.ata_port | 0, this, function() { return this.current_interface.read_data(1); }, function() { return this.current_interface.read_data(2); }, function() { return this.current_interface.read_data(4); }); cpu.io.register_read(this.ata_port | 1, this, function() { dbg_log("Read error: " + h(this.current_interface.error & 0xFF) + " slave=" + (this.current_interface === this.slave), LOG_DISK); return this.current_interface.error & 0xFF; }); cpu.io.register_read(this.ata_port | 2, this, function() { dbg_log("Read bytecount: " + h(this.current_interface.bytecount & 0xFF), LOG_DISK); return this.current_interface.bytecount & 0xFF; }); cpu.io.register_read(this.ata_port | 3, this, function() { dbg_log("Read sector: " + h(this.current_interface.sector & 0xFF), LOG_DISK); return this.current_interface.sector & 0xFF; }); cpu.io.register_read(this.ata_port | 4, this, function() { dbg_log("Read 1F4: " + h(this.current_interface.cylinder_low & 0xFF), LOG_DISK); return this.current_interface.cylinder_low & 0xFF; }); cpu.io.register_read(this.ata_port | 5, this, function() { dbg_log("Read 1F5: " + h(this.current_interface.cylinder_high & 0xFF), LOG_DISK); return this.current_interface.cylinder_high & 0xFF; }); cpu.io.register_read(this.ata_port | 6, this, function() { dbg_log("Read 1F6", LOG_DISK); return this.current_interface.drive_head & 0xFF; }); cpu.io.register_write(this.ata_port | 0, this, function(data) { this.current_interface.write_data_port8(data); }, function(data) { this.current_interface.write_data_port16(data); }, function(data) { this.current_interface.write_data_port32(data); }); cpu.io.register_write(this.ata_port | 1, this, function(data) { dbg_log("1F1/lba_count: " + h(data), LOG_DISK); this.master.lba_count = (this.master.lba_count << 8 | data) & 0xFFFF; this.slave.lba_count = (this.slave.lba_count << 8 | data) & 0xFFFF; }); cpu.io.register_write(this.ata_port | 2, this, function(data) { dbg_log("1F2/bytecount: " + h(data), LOG_DISK); this.master.bytecount = (this.master.bytecount << 8 | data) & 0xFFFF; this.slave.bytecount = (this.slave.bytecount << 8 | data) & 0xFFFF; }); cpu.io.register_write(this.ata_port | 3, this, function(data) { dbg_log("1F3/sector: " + h(data), LOG_DISK); this.master.sector = (this.master.sector << 8 | data) & 0xFFFF; this.slave.sector = (this.slave.sector << 8 | data) & 0xFFFF; }); cpu.io.register_write(this.ata_port | 4, this, function(data) { dbg_log("1F4/sector low: " + h(data), LOG_DISK); this.master.cylinder_low = (this.master.cylinder_low << 8 | data) & 0xFFFF; this.slave.cylinder_low = (this.slave.cylinder_low << 8 | data) & 0xFFFF; }); cpu.io.register_write(this.ata_port | 5, this, function(data) { dbg_log("1F5/sector high: " + h(data), LOG_DISK); this.master.cylinder_high = (this.master.cylinder_high << 8 | data) & 0xFFFF; this.slave.cylinder_high = (this.slave.cylinder_high << 8 | data) & 0xFFFF; }); cpu.io.register_write(this.ata_port | 6, this, function(data) { var slave = data & 0x10; var mode = data & 0xE0; dbg_log("1F6/drive: " + h(data, 2), LOG_DISK); if(slave) { dbg_log("Slave", LOG_DISK); this.current_interface = this.slave; } else { this.current_interface = this.master; } this.master.drive_head = data; this.slave.drive_head = data; this.master.is_lba = this.slave.is_lba = data >> 6 & 1; this.master.head = this.slave.head = data & 0xF; }); /** @type {number} */ this.prdt_addr = 0; /** @type {number} */ this.dma_status = 0; /** @type {number} */ this.dma_command = 0; cpu.io.register_write(this.ata_port | 7, this, function(data) { dbg_log("lower irq", LOG_DISK); this.cpu.device_lower_irq(this.irq); this.current_interface.ata_command(data); }); cpu.io.register_read(this.master_port | 4, this, undefined, undefined, this.dma_read_addr); cpu.io.register_write(this.master_port | 4, this, undefined, undefined, this.dma_set_addr); cpu.io.register_read(this.master_port, this, this.dma_read_command8, undefined, this.dma_read_command); cpu.io.register_write(this.master_port, this, this.dma_write_command8, undefined, this.dma_write_command); cpu.io.register_read(this.master_port | 2, this, this.dma_read_status); cpu.io.register_write(this.master_port | 2, this, this.dma_write_status); cpu.io.register_read(this.master_port | 0x8, this, function() { dbg_log("DMA read 0x8", LOG_DISK); return 0; }); cpu.io.register_read(this.master_port | 0xA, this, function() { dbg_log("DMA read 0xA", LOG_DISK); return 0; }); cpu.devices.pci.register_device(this); DEBUG && Object.seal(this); } IDEDevice.prototype.read_status = function() { if(this.current_interface.buffer) { var ret = this.current_interface.status; dbg_log("ATA read status: " + h(ret, 2), LOG_DISK); return ret; } else { return 0; } }; IDEDevice.prototype.write_control = function(data) { dbg_log("set device control: " + h(data, 2) + " interrupts " + ((data & 2) ? "disabled" : "enabled"), LOG_DISK); if(data & 4) { dbg_log("Reset via control port", LOG_DISK); this.cpu.device_lower_irq(this.irq); this.master.device_reset(); this.slave.device_reset(); } this.device_control = data; }; IDEDevice.prototype.dma_read_addr = function() { dbg_log("dma get address: " + h(this.prdt_addr, 8), LOG_DISK); return this.prdt_addr; }; IDEDevice.prototype.dma_set_addr = function(data) { dbg_log("dma set address: " + h(data, 8), LOG_DISK); this.prdt_addr = data; }; IDEDevice.prototype.dma_read_status = function() { dbg_log("DMA read status: " + h(this.dma_status), LOG_DISK); return this.dma_status; }; IDEDevice.prototype.dma_write_status = function(value) { dbg_log("DMA set status: " + h(value), LOG_DISK); this.dma_status &= ~(value & 6); }; IDEDevice.prototype.dma_read_command = function() { return this.dma_read_command8() | this.dma_read_status() << 16; }; IDEDevice.prototype.dma_read_command8 = function() { dbg_log("DMA read command: " + h(this.dma_command), LOG_DISK); return this.dma_command; }; IDEDevice.prototype.dma_write_command = function(value) { dbg_log("DMA write command: " + h(value), LOG_DISK); this.dma_write_command8(value & 0xFF); this.dma_write_status(value >> 16 & 0xFF); }; IDEDevice.prototype.dma_write_command8 = function(value) { dbg_log("DMA write command8: " + h(value), LOG_DISK); let old_command = this.dma_command; this.dma_command = value & 0x9; if((old_command & 1) === (value & 1)) { return; } if((value & 1) === 0) { this.dma_status &= ~1; return; } this.dma_status |= 1; switch(this.current_interface.current_command) { case 0x25: case 0xC8: this.current_interface.do_ata_read_sectors_dma(); break; case 0xCA: case 0x35: this.current_interface.do_ata_write_sectors_dma(); break; case 0xA0: this.current_interface.do_atapi_dma(); break; default: dbg_log("Spurious dma command write, current command: " + h(this.current_interface.current_command), LOG_DISK); dbg_assert(false); } }; IDEDevice.prototype.push_irq = function() { if((this.device_control & 2) === 0) { dbg_log("push irq", LOG_DISK); this.dma_status |= 4; this.cpu.device_raise_irq(this.irq); } }; IDEDevice.prototype.get_state = function() { var state = []; state[0] = this.master; state[1] = this.slave; state[2] = this.ata_port; state[3] = this.irq; state[4] = this.pci_id; state[5] = this.ata_port_high; state[6] = this.master_port; state[7] = this.name; state[8] = this.device_control; state[9] = this.prdt_addr; state[10] = this.dma_status; state[11] = this.current_interface === this.master; state[12] = this.dma_command; return state; }; IDEDevice.prototype.set_state = function(state) { this.master.set_state(state[0]); this.slave.set_state(state[1]); this.ata_port = state[2]; this.irq = state[3]; this.pci_id = state[4]; this.ata_port_high = state[5]; this.master_port = state[6]; this.name = state[7]; this.device_control = state[8]; this.prdt_addr = state[9]; this.dma_status = state[10]; this.current_interface = state[11] ? this.master : this.slave; this.dma_command = state[12]; }; /** * @constructor */ function IDEInterface(device, cpu, buffer, is_cd, device_nr, interface_nr, bus) { this.device = device; /** @const @type {BusConnector} */ this.bus = bus; /** * @const * @type {number} */ this.nr = device_nr; /** @const @type {CPU} */ this.cpu = cpu; this.buffer = buffer; /** @type {number} */ this.sector_size = is_cd ? CDROM_SECTOR_SIZE : HD_SECTOR_SIZE; /** @type {boolean} */ this.is_atapi = is_cd; /** @type {number} */ this.sector_count = 0; /** @type {number} */ this.head_count = 0; /** @type {number} */ this.sectors_per_track = 0; /** @type {number} */ this.cylinder_count = 0; if(this.buffer) { this.sector_count = this.buffer.byteLength / this.sector_size; if(this.sector_count !== (this.sector_count | 0)) { dbg_log("Warning: Disk size not aligned with sector size", LOG_DISK); this.sector_count = Math.ceil(this.sector_count); } if(is_cd) { this.head_count = 1; this.sectors_per_track = 0; } else { // "default" values: 16/63 // common: 255, 63 this.head_count = 16; this.sectors_per_track = 63; } this.cylinder_count = this.sector_count / this.head_count / this.sectors_per_track; if(this.cylinder_count !== (this.cylinder_count | 0)) { dbg_log("Warning: Rounding up cylinder count. Choose different head number", LOG_DISK); this.cylinder_count = Math.floor(this.cylinder_count); //this.sector_count = this.cylinder_count * this.head_count * // this.sectors_per_track * this.sector_size; } //if(this.cylinder_count > 16383) //{ // this.cylinder_count = 16383; //} // disk translation: lba var rtc = cpu.devices.rtc; // master rtc.cmos_write(CMOS_BIOS_DISKTRANSFLAG, rtc.cmos_read(CMOS_BIOS_DISKTRANSFLAG) | 1 << this.nr * 4); rtc.cmos_write(CMOS_DISK_DATA, rtc.cmos_read(CMOS_DISK_DATA) & 0x0F | 0xF0); var reg = CMOS_DISK_DRIVE1_CYL; rtc.cmos_write(reg + 0, this.cylinder_count & 0xFF); rtc.cmos_write(reg + 1, this.cylinder_count >> 8 & 0xFF); rtc.cmos_write(reg + 2, this.head_count & 0xFF); rtc.cmos_write(reg + 3, 0xFF); rtc.cmos_write(reg + 4, 0xFF); rtc.cmos_write(reg + 5, 0xC8); rtc.cmos_write(reg + 6, this.cylinder_count & 0xFF); rtc.cmos_write(reg + 7, this.cylinder_count >> 8 & 0xFF); rtc.cmos_write(reg + 8, this.sectors_per_track & 0xFF); //rtc.cmos_write(CMOS_BIOS_DISKTRANSFLAG, // rtc.cmos_read(CMOS_BIOS_DISKTRANSFLAG) | 1 << (nr * 4 + 2)); // slave } /** @const */ this.stats = { sectors_read: 0, sectors_written: 0, bytes_read: 0, bytes_written: 0, loading: false, }; this.buffer = buffer; /** @type {number} */ this.is_lba = 0; /** @type {number} */ this.bytecount = 0; /** @type {number} */ this.sector = 0; /** @type {number} */ this.lba_count = 0; /** @type {number} */ this.cylinder_low = 0; /** @type {number} */ this.cylinder_high = 0; /** @type {number} */ this.head = 0; /** @type {number} */ this.drive_head = 0; /** @type {number} */ this.status = 0x50; /** @type {number} */ this.sectors_per_drq = 0x80; /** @type {number} */ this.error = 0; /** @type {number} */ this.data_pointer = 0; this.data = new Uint8Array(64 * 1024); this.data16 = new Uint16Array(this.data.buffer); this.data32 = new Int32Array(this.data.buffer); /** @type {number} */ this.data_length = 0; /** @type {number} */ this.data_end = 0; /** @type {number} */ this.current_command = -1; /** @type {number} */ this.current_atapi_command = -1; /** @type {number} */ this.write_dest = 0; // cancellation support this.last_io_id = 0; this.in_progress_io_ids = new Set(); this.cancelled_io_ids = new Set(); Object.seal(this); } IDEInterface.prototype.device_reset = function() { if(this.is_atapi) { this.status = 0; this.bytecount = 1; this.error = 1; this.sector = 1; // lba_low this.cylinder_low = 0x14; // lba_mid this.cylinder_high = 0xEB; // lba_high } else { this.status = 0x50 | 1; this.bytecount = 1; this.error = 1; this.sector = 1; // lba_low // 0, 0 needed by bochs bios this.cylinder_low = 0; // lba_mid this.cylinder_high = 0; // lba_high } this.cancel_io_operations(); }; IDEInterface.prototype.push_irq = function() { this.device.push_irq(); }; IDEInterface.prototype.ata_command = function(cmd) { dbg_log("ATA Command: " + h(cmd) + " slave=" + (this.drive_head >> 4 & 1), LOG_DISK); if(!this.buffer) { dbg_log("abort: No buffer", LOG_DISK); this.error = 4; this.status = 0x41; this.push_irq(); return; } this.current_command = cmd; this.error = 0; switch(cmd) { case 0x08: dbg_log("ATA device reset", LOG_DISK); this.data_pointer = 0; this.data_end = 0; this.data_length = 0; this.device_reset(); this.push_irq(); break; case 0x10: // calibrate drive this.status = 0x50; this.cylinder_low = 0; this.push_irq(); break; case 0xF8: // read native max address this.status = 0x50; var last_sector = this.sector_count - 1; this.sector = last_sector & 0xFF; this.cylinder_low = last_sector >> 8 & 0xFF; this.cylinder_high = last_sector >> 16 & 0xFF; this.drive_head = this.drive_head & 0xF0 | last_sector >> 24 & 0x0F; this.push_irq(); break; case 0x27: // read native max address ext this.status = 0x50; var last_sector = this.sector_count - 1; this.sector = last_sector & 0xFF; this.cylinder_low = last_sector >> 8 & 0xFF; this.cylinder_high = last_sector >> 16 & 0xFF; this.sector |= last_sector >> 24 << 8 & 0xFF00; this.push_irq(); break; case 0x20: case 0x24: case 0x29: case 0xC4: // 0x20 read sectors // 0x24 read sectors ext // 0xC4 read multiple // 0x29 read multiple ext this.ata_read_sectors(cmd); break; case 0x30: case 0x34: case 0x39: case 0xC5: // 0x30 write sectors // 0x34 write sectors ext // 0xC5 write multiple // 0x39 write multiple ext this.ata_write_sectors(cmd); break; case 0x90: // execute device diagnostic this.push_irq(); this.error = 0x101; this.status = 0x50; break; case 0x91: // initialize device parameters this.status = 0x50; this.push_irq(); break; case 0xA0: // ATA packet if(this.is_atapi) { this.status = 0x58; this.data_allocate(12); this.data_end = 12; this.bytecount = 1; this.push_irq(); } break; case 0xA1: dbg_log("ATA identify packet device", LOG_DISK); if(this.is_atapi) { this.create_identify_packet(); this.status = 0x58; this.cylinder_low = 0x14; this.cylinder_high = 0xEB; this.push_irq(); } else { this.status = 0x41; this.push_irq(); } break; case 0xC6: // set multiple mode // Logical sectors per DRQ Block in word 1 dbg_log("Logical sectors per DRQ Block: " + h(this.bytecount & 0xFF), LOG_DISK); this.sectors_per_drq = this.bytecount & 0xFF; this.status = 0x50; this.push_irq(); break; case 0x25: // read dma ext case 0xC8: // read dma this.ata_read_sectors_dma(cmd); break; case 0x35: // write dma ext case 0xCA: // write dma this.ata_write_sectors_dma(cmd); break; case 0x40: dbg_log("read verify sectors", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xDA: dbg_log("Unimplemented: get media status", LOG_DISK); this.status = 0x41; this.error = 4; this.push_irq(); break; case 0xE0: dbg_log("ATA standby immediate", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xE1: dbg_log("ATA idle immediate", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xE7: dbg_log("ATA flush cache", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xEC: dbg_log("ATA identify device", LOG_DISK); if(this.is_atapi) { this.status = 0x41; this.error = 4; this.push_irq(); return; } this.create_identify_packet(); this.status = 0x58; this.push_irq(); break; case 0xEA: dbg_log("flush cache ext", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xEF: dbg_log("set features: " + h(this.bytecount & 0xFF), LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xF5: dbg_log("security freeze lock", LOG_DISK); this.status = 0x50; this.push_irq(); break; case 0xF9: dbg_log("Unimplemented: set max address", LOG_DISK); this.status = 0x41; this.error = 4; break; default: dbg_assert(false, "New ATA cmd on 1F7: " + h(cmd), LOG_DISK); this.status = 0x41; // abort bit set this.error = 4; } }; IDEInterface.prototype.atapi_handle = function() { dbg_log("ATAPI Command: " + h(this.data[0]) + " slave=" + (this.drive_head >> 4 & 1), LOG_DISK); this.data_pointer = 0; this.current_atapi_command = this.data[0]; switch(this.current_atapi_command) { case 0x00: dbg_log("test unit ready", LOG_DISK); // test unit ready this.data_allocate(0); this.data_end = this.data_length; this.status = 0x50; break; case 0x03: // request sense this.data_allocate(this.data[4]); this.data_end = this.data_length; this.status = 0x58; this.data[0] = 0x80 | 0x70; this.data[2] = 5; // illegal request this.data[7] = 8; break; case 0x12: // inquiry var length = this.data[4]; this.status = 0x58; dbg_log("inquiry: " + h(this.data[1], 2) + " length=" + length, LOG_DISK); // http://www.t10.org/ftp/x3t9.2/document.87/87-106r0.txt //this.data_allocate(36); this.data.set([ 0x05, 0x80, 0x01, 0x31, // additional length 31, 0, 0, 0, // 8 0x53, 0x4F, 0x4E, 0x59, 0x20, 0x20, 0x20, 0x20, // 16 0x43, 0x44, 0x2D, 0x52, 0x4F, 0x4D, 0x20, 0x43, 0x44, 0x55, 0x2D, 0x31, 0x30, 0x30, 0x30, 0x20, // 32 0x31, 0x2E, 0x31, 0x61, ]); this.data_end = this.data_length = Math.min(36, length); break; case 0x1A: // mode sense (6) this.data_allocate(this.data[4]); this.data_end = this.data_length; this.status = 0x58; break; case 0x1E: // prevent/allow medium removal this.data_allocate(0); this.data_end = this.data_length; this.status = 0x50; break; case 0x25: // read capacity var count = this.sector_count - 1; this.data_set(new Uint8Array([ count >> 24 & 0xFF, count >> 16 & 0xFF, count >> 8 & 0xFF, count & 0xFF, 0, 0, this.sector_size >> 8 & 0xFF, this.sector_size & 0xFF, ])); this.data_end = this.data_length; this.status = 0x58; break; case 0x28: // read if(this.lba_count & 1) { this.atapi_read_dma(this.data); } else { this.atapi_read(this.data); } break; case 0x42: var length = this.data[8]; this.data_allocate(Math.min(8, length)); this.data_end = this.data_length; dbg_log("read q subcode: length=" + length, LOG_DISK); this.status = 0x58; break; case 0x43: // read toc var length = this.data[8] | this.data[7] << 8; var format = this.data[9] >> 6; this.data_allocate(length); this.data_end = this.data_length; dbg_log("read toc: " + h(format, 2) + " length=" + length + " " + (this.data[1] & 2) + " " + h(this.data[6]), LOG_DISK); if(format === 0) { var sector_count = this.sector_count; this.data.set(new Uint8Array([ 0, 18, // length 1, 1, // first and last session 0, 0x14, 1, // track number 0, 0, 0, 0, 0, 0, 0x16, 0xAA, // track number 0, sector_count >> 24, sector_count >> 16 & 0xFF, sector_count >> 8 & 0xFF, sector_count & 0xFF, ])); } else if(format === 1) { this.data.set(new Uint8Array([ 0, 10, // length 1, 1, // first and last session 0, 0, 0, 0, 0, 0, 0, 0, ])); } else { dbg_assert(false, "Unimplemented format: " + format); } this.status = 0x58; break; case 0x46: // get configuration var length = this.data[8] | this.data[7] << 8; length = Math.min(length, 32); this.data_allocate(length); this.data_end = this.data_length; this.data[0] = length - 4 >> 24 & 0xFF; this.data[1] = length - 4 >> 16 & 0xFF; this.data[2] = length - 4 >> 8 & 0xFF; this.data[3] = length - 4 & 0xFF; this.data[6] = 0x08; this.data[10] = 3; this.status = 0x58; break; case 0x51: // read disk information this.data_allocate(0); this.data_end = this.data_length; this.status = 0x50; break; case 0x52: dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK); this.status = 0x51; this.data_length = 0; this.error = 5 << 4; break; case 0x5A: // mode sense var length = this.data[8] | this.data[7] << 8; var page_code = this.data[2]; dbg_log("mode sense: " + h(page_code) + " length=" + length, LOG_DISK); if(page_code === 0x2A) { this.data_allocate(Math.min(30, length)); } this.data_end = this.data_length; this.status = 0x58; break; case 0xBD: // mechanism status this.data_allocate(this.data[9] | this.data[8] << 8); this.data_end = this.data_length; this.data[5] = 1; this.status = 0x58; break; case 0x4A: this.status = 0x51; this.data_length = 0; this.error = 5 << 4; dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK); break; default: this.status = 0x51; this.data_length = 0; this.error = 5 << 4; dbg_log("Unimplemented ATAPI command: " + h(this.data[0]), LOG_DISK); dbg_assert(false); } this.bytecount = this.bytecount & ~7 | 2; if((this.status & 0x80) === 0) { this.push_irq(); } if((this.status & 0x80) === 0 && this.data_length === 0) { this.bytecount |= 1; this.status &= ~8; } }; IDEInterface.prototype.do_write = function() { this.status = 0x50; dbg_assert(this.data_length <= this.data.length); var data = this.data.subarray(0, this.data_length); //dbg_log(hex_dump(data), LOG_DISK); dbg_assert(this.data_length % 512 === 0); this.ata_advance(this.current_command, this.data_length / 512); this.push_irq(); this.buffer.set(this.write_dest, data, function() { }); this.report_write(this.data_length); }; IDEInterface.prototype.atapi_read = function(cmd) { // Note: Big Endian var lba = cmd[2] << 24 | cmd[3] << 16 | cmd[4] << 8 | cmd[5]; var count = cmd[7] << 8 | cmd[8]; var flags = cmd[1]; var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("CD read lba=" + h(lba) + " lbacount=" + h(count) + " bytecount=" + h(byte_count) + " flags=" + h(flags), LOG_DISK); this.data_length = 0; var req_length = this.cylinder_high << 8 & 0xFF00 | this.cylinder_low & 0xFF; dbg_log(h(this.cylinder_high, 2) + " " + h(this.cylinder_low, 2), LOG_DISK); this.cylinder_low = this.cylinder_high = 0; // oak technology driver (windows 3.0) if(req_length === 0xFFFF) req_length--; if(req_length > byte_count) { req_length = byte_count; } if(start >= this.buffer.byteLength) { dbg_assert(false, "CD read: Outside of disk end=" + h(start + byte_count) + " size=" + h(this.buffer.byteLength), LOG_DISK); this.status = 0xFF; this.push_irq(); } else if(byte_count === 0) { this.status = 0x50; this.data_pointer = 0; //this.push_irq(); } else { byte_count = Math.min(byte_count, this.buffer.byteLength - start); this.status = 0x50 | 0x80; this.report_read_start(); this.read_buffer(start, byte_count, (data) => { //setTimeout(() => { dbg_log("cd read: data arrived", LOG_DISK); this.data_set(data); this.status = 0x58; this.bytecount = this.bytecount & ~7 | 2; this.push_irq(); req_length &= ~3; this.data_end = req_length; if(this.data_end > this.data_length) { this.data_end = this.data_length; } this.cylinder_low = this.data_end & 0xFF; this.cylinder_high = this.data_end >> 8 & 0xFF; this.report_read_end(byte_count); //}, 10); }); } }; IDEInterface.prototype.atapi_read_dma = function(cmd) { // Note: Big Endian var lba = cmd[2] << 24 | cmd[3] << 16 | cmd[4] << 8 | cmd[5]; var count = cmd[7] << 8 | cmd[8]; var flags = cmd[1]; var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("CD read DMA lba=" + h(lba) + " lbacount=" + h(count) + " bytecount=" + h(byte_count) + " flags=" + h(flags), LOG_DISK); if(start >= this.buffer.byteLength) { dbg_assert(false, "CD read: Outside of disk end=" + h(start + byte_count) + " size=" + h(this.buffer.byteLength), LOG_DISK); this.status = 0xFF; this.push_irq(); } else { this.status = 0x50 | 0x80; this.report_read_start(); this.read_buffer(start, byte_count, (data) => { dbg_log("atapi_read_dma: Data arrived"); this.report_read_end(byte_count); this.status = 0x58; this.bytecount = this.bytecount & ~7 | 2; this.data_set(data); this.do_atapi_dma(); }); } }; IDEInterface.prototype.do_atapi_dma = function() { if((this.device.dma_status & 1) === 0) { dbg_log("do_atapi_dma: Status not set", LOG_DISK); return; } if((this.status & 0x8) === 0) { dbg_log("do_atapi_dma: DRQ not set", LOG_DISK); return; } dbg_log("atapi dma transfer len=" + this.data_length, LOG_DISK); var prdt_start = this.device.prdt_addr; var offset = 0; var data = this.data; do { var addr = this.cpu.read32s(prdt_start); var count = this.cpu.read16(prdt_start + 4); var end = this.cpu.read8(prdt_start + 7) & 0x80; if(!count) { count = 0x10000; } dbg_log("dma read dest=" + h(addr) + " count=" + h(count) + " datalen=" + h(this.data_length), LOG_DISK); this.cpu.write_blob(data.subarray(offset, Math.min(offset + count, this.data_length)), addr); offset += count; prdt_start += 8; if(offset >= this.data_length && !end) { dbg_log("leave early end=" + (+end) + " offset=" + h(offset) + " data_length=" + h(this.data_length) + " cmd=" + h(this.current_command), LOG_DISK); break; } } while(!end); dbg_log("end offset=" + offset, LOG_DISK); this.status = 0x50; this.device.dma_status &= ~1; this.bytecount = this.bytecount & ~7 | 3; this.push_irq(); }; IDEInterface.prototype.read_data = function(length) { if(this.data_pointer < this.data_end) { dbg_assert(this.data_pointer + length - 1 < this.data_end); dbg_assert(this.data_pointer % length === 0, h(this.data_pointer) + " " + length); if(length === 1) { var result = this.data[this.data_pointer]; } else if(length === 2) { var result = this.data16[this.data_pointer >>> 1]; } else { var result = this.data32[this.data_pointer >>> 2]; } this.data_pointer += length; var align = (this.data_end & 0xFFF) === 0 ? 0xFFF : 0xFF; if((this.data_pointer & align) === 0) { dbg_log("Read 1F0: " + h(this.data[this.data_pointer], 2) + " cur=" + h(this.data_pointer) + " cnt=" + h(this.data_length), LOG_DISK); } if(this.data_pointer >= this.data_end) { this.read_end(); } return result; } else { dbg_log("Read 1F0: empty", LOG_DISK); this.data_pointer += length; return 0; } }; IDEInterface.prototype.read_end = function() { dbg_log("read_end cmd=" + h(this.current_command) + " data_pointer=" + h(this.data_pointer) + " end=" + h(this.data_end) + " length=" + h(this.data_length), LOG_DISK); if(this.current_command === 0xA0) { if(this.data_end === this.data_length) { this.status = 0x50; this.bytecount = this.bytecount & ~7 | 3; this.push_irq(); } else { this.status = 0x58; this.bytecount = this.bytecount & ~7 | 2; this.push_irq(); var byte_count = this.cylinder_high << 8 & 0xFF00 | this.cylinder_low & 0xFF; if(this.data_end + byte_count > this.data_length) { this.cylinder_low = (this.data_length - this.data_end) & 0xFF; this.cylinder_high = (this.data_length - this.data_end) >> 8 & 0xFF; this.data_end = this.data_length; } else { this.data_end += byte_count; } dbg_log("data_end=" + h(this.data_end), LOG_DISK); } } else { this.error = 0; if(this.data_pointer >= this.data_length) { this.status = 0x50; this.push_irq(); } else { if(this.current_command === 0xC4 || this.current_command === 0x29) { var sector_count = Math.min(this.sectors_per_drq, (this.data_length - this.data_end) / 512); dbg_assert(sector_count % 1 === 0); } else { dbg_assert(this.current_command === 0x20 || this.current_command === 0x24); var sector_count = 1; } this.ata_advance(this.current_command, sector_count); this.data_end += 512 * sector_count; this.status = 0x58; this.push_irq(); } } }; IDEInterface.prototype.write_data_port = function(data, length) { dbg_assert(this.data_pointer % length === 0); if(this.data_pointer >= this.data_end) { dbg_log("Redundant write to data port: " + h(data) + " count=" + h(this.data_end) + " cur=" + h(this.data_pointer), LOG_DISK); } else { var align = (this.data_end & 0xFFF) === 0 ? 0xFFF : 0xFF; if((this.data_pointer + length & align) === 0 || this.data_end < 20) { dbg_log("Data port: " + h(data >>> 0) + " count=" + h(this.data_end) + " cur=" + h(this.data_pointer), LOG_DISK); } if(length === 1) { this.data[this.data_pointer++] = data; } else if(length === 2) { this.data16[this.data_pointer >>> 1] = data; this.data_pointer += 2; } else { this.data32[this.data_pointer >>> 2] = data; this.data_pointer += 4; } dbg_assert(this.data_pointer <= this.data_end); if(this.data_pointer === this.data_end) { this.write_end(); } } }; IDEInterface.prototype.write_data_port8 = function(data) { this.write_data_port(data, 1); }; IDEInterface.prototype.write_data_port16 = function(data) { this.write_data_port(data, 2); }; IDEInterface.prototype.write_data_port32 = function(data) { this.write_data_port(data, 4); }; IDEInterface.prototype.write_end = function() { if(this.current_command === 0xA0) { this.atapi_handle(); } else { dbg_log("write_end data_pointer=" + h(this.data_pointer) + " data_length=" + h(this.data_length), LOG_DISK); if(this.data_pointer >= this.data_length) { this.do_write(); } else { dbg_assert(this.current_command === 0x30 || this.current_command === 0x34 || this.current_command === 0xC5, "Unexpected command: " + h(this.current_command)); // XXX: Should advance here, but do_write does all the advancing //this.ata_advance(this.current_command, 1); this.status = 0x58; this.data_end += 512; this.push_irq(); } } }; IDEInterface.prototype.ata_advance = function(cmd, sectors) { dbg_log("Advance sectors=" + sectors + " old_bytecount=" + this.bytecount, LOG_DISK); this.bytecount -= sectors; if(cmd === 0x24 || cmd === 0x29 || cmd === 0x34 || cmd === 0x39 || cmd === 0x25 || cmd === 0x35) { var new_sector = sectors + this.get_lba48(); this.sector = new_sector & 0xFF | new_sector >> 16 & 0xFF00; this.cylinder_low = new_sector >> 8 & 0xFF; this.cylinder_high = new_sector >> 16 & 0xFF; } else if(this.is_lba) { var new_sector = sectors + this.get_lba28(); this.sector = new_sector & 0xFF; this.cylinder_low = new_sector >> 8 & 0xFF; this.cylinder_high = new_sector >> 16 & 0xFF; this.head = this.head & ~0xF | new_sector & 0xF; } else // chs { var new_sector = sectors + this.get_chs(); var c = new_sector / (this.head_count * this.sectors_per_track) | 0; this.cylinder_low = c & 0xFF; this.cylinder_high = c >> 8 & 0xFF; this.head = (new_sector / this.sectors_per_track | 0) % this.head_count & 0xF; this.sector = (new_sector % this.sectors_per_track + 1) & 0xFF; dbg_assert(new_sector === this.get_chs()); } }; IDEInterface.prototype.ata_read_sectors = function(cmd) { var is_lba48 = cmd === 0x24 || cmd === 0x29; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var is_single = cmd === 0x20 || cmd === 0x24; var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("ATA read cmd=" + h(cmd) + " mode=" + (this.is_lba ? "lba" : "chs") + " lba=" + h(lba) + " lbacount=" + h(count) + " bytecount=" + h(byte_count), LOG_DISK); if(start + byte_count > this.buffer.byteLength) { dbg_assert(false, "ATA read: Outside of disk", LOG_DISK); this.status = 0xFF; this.push_irq(); } else { this.status = 0x80 | 0x40; this.report_read_start(); this.read_buffer(start, byte_count, (data) => { //setTimeout(() => { dbg_log("ata_read: Data arrived", LOG_DISK); this.data_set(data); this.status = 0x58; this.data_end = is_single ? 512 : Math.min(byte_count, this.sectors_per_drq * 512); this.ata_advance(cmd, is_single ? 1 : Math.min(count, this.sectors_per_track)); this.push_irq(); this.report_read_end(byte_count); //}, 10); }); } }; IDEInterface.prototype.ata_read_sectors_dma = function(cmd) { var is_lba48 = cmd === 0x25; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("ATA DMA read lba=" + h(lba) + " lbacount=" + h(count) + " bytecount=" + h(byte_count), LOG_DISK); if(start + byte_count > this.buffer.byteLength) { dbg_assert(false, "ATA read: Outside of disk", LOG_DISK); this.status = 0xFF; this.push_irq(); return; } this.status = 0x58; this.device.dma_status |= 1; }; IDEInterface.prototype.do_ata_read_sectors_dma = function() { var cmd = this.current_command; var is_lba48 = cmd === 0x25; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_assert(lba < this.buffer.byteLength); this.report_read_start(); var orig_prdt_start = this.device.prdt_addr; this.read_buffer(start, byte_count, (data) => { //setTimeout(function() { dbg_log("do_ata_read_sectors_dma: Data arrived", LOG_DISK); var prdt_start = this.device.prdt_addr; var offset = 0; dbg_assert(orig_prdt_start === prdt_start); do { var prd_addr = this.cpu.read32s(prdt_start); var prd_count = this.cpu.read16(prdt_start + 4); var end = this.cpu.read8(prdt_start + 7) & 0x80; if(!prd_count) { prd_count = 0x10000; dbg_log("dma: prd count was 0", LOG_DISK); } dbg_log("dma read transfer dest=" + h(prd_addr) + " prd_count=" + h(prd_count), LOG_DISK); this.cpu.write_blob(data.subarray(offset, offset + prd_count), prd_addr); offset += prd_count; prdt_start += 8; } while(!end); dbg_assert(offset === byte_count); this.ata_advance(this.current_command, count); this.status = 0x50; this.device.dma_status &= ~1; this.current_command = -1; this.push_irq(); this.report_read_end(byte_count); //}.bind(this), 10); }); }; IDEInterface.prototype.ata_write_sectors = function(cmd) { var is_lba48 = cmd === 0x34 || cmd === 0x39; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var is_single = cmd === 0x30 || cmd === 0x34; var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("ATA write lba=" + h(lba) + " mode=" + (this.is_lba ? "lba" : "chs") + " lbacount=" + h(count) + " bytecount=" + h(byte_count), LOG_DISK); if(start + byte_count > this.buffer.byteLength) { dbg_assert(false, "ATA write: Outside of disk", LOG_DISK); this.status = 0xFF; this.push_irq(); } else { this.status = 0x58; this.data_allocate_noclear(byte_count); this.data_end = is_single ? 512 : Math.min(byte_count, this.sectors_per_drq * 512); this.write_dest = start; } }; IDEInterface.prototype.ata_write_sectors_dma = function(cmd) { var is_lba48 = cmd === 0x35; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var byte_count = count * this.sector_size; var start = lba * this.sector_size; dbg_log("ATA DMA write lba=" + h(lba) + " lbacount=" + h(count) + " bytecount=" + h(byte_count), LOG_DISK); if(start + byte_count > this.buffer.byteLength) { dbg_assert(false, "ATA DMA write: Outside of disk", LOG_DISK); this.status = 0xFF; this.push_irq(); return; } this.status = 0x58; this.device.dma_status |= 1; }; IDEInterface.prototype.do_ata_write_sectors_dma = function() { var cmd = this.current_command; var is_lba48 = cmd === 0x35; var count = this.get_count(is_lba48); var lba = this.get_lba(is_lba48); var byte_count = count * this.sector_size; var start = lba * this.sector_size; var prdt_start = this.device.prdt_addr; var offset = 0; dbg_log("prdt addr: " + h(prdt_start, 8), LOG_DISK); const buffer = new Uint8Array(byte_count); do { var prd_addr = this.cpu.read32s(prdt_start); var prd_count = this.cpu.read16(prdt_start + 4); var end = this.cpu.read8(prdt_start + 7) & 0x80; if(!prd_count) { prd_count = 0x10000; dbg_log("dma: prd count was 0", LOG_DISK); } dbg_log("dma write transfer dest=" + h(prd_addr) + " prd_count=" + h(prd_count), LOG_DISK); var slice = this.cpu.mem8.subarray(prd_addr, prd_addr + prd_count); dbg_assert(slice.length === prd_count); buffer.set(slice, offset); //if(DEBUG) //{ // dbg_log(hex_dump(slice), LOG_DISK); //} offset += prd_count; prdt_start += 8; } while(!end); dbg_assert(offset === buffer.length); this.buffer.set(start, buffer, () => { dbg_log("dma write completed", LOG_DISK); this.ata_advance(this.current_command, count); this.status = 0x50; this.push_irq(); this.device.dma_status &= ~1; this.current_command = -1; }); this.report_write(byte_count); }; IDEInterface.prototype.get_chs = function() { var c = this.cylinder_low & 0xFF | this.cylinder_high << 8 & 0xFF00; var h = this.head; var s = this.sector & 0xFF; dbg_log("get_chs: c=" + c + " h=" + h + " s=" + s, LOG_DISK); return (c * this.head_count + h) * this.sectors_per_track + s - 1; }; IDEInterface.prototype.get_lba28 = function() { return this.sector & 0xFF | this.cylinder_low << 8 & 0xFF00 | this.cylinder_high << 16 & 0xFF0000 | (this.head & 0xF) << 24; }; IDEInterface.prototype.get_lba48 = function() { // Note: Bits over 32 missing return (this.sector & 0xFF | this.cylinder_low << 8 & 0xFF00 | this.cylinder_high << 16 & 0xFF0000 | (this.sector >> 8) << 24 & 0xFF000000) >>> 0; }; IDEInterface.prototype.get_lba = function(is_lba48) { if(is_lba48) { return this.get_lba48(); } else if(this.is_lba) { return this.get_lba28(); } else { return this.get_chs(); } }; IDEInterface.prototype.get_count = function(is_lba48) { if(is_lba48) { var count = this.bytecount; if(count === 0) count = 0x10000; return count; } else { var count = this.bytecount & 0xFF; if(count === 0) count = 0x100; return count; } }; IDEInterface.prototype.create_identify_packet = function() { // http://bochs.sourceforge.net/cgi-bin/lxr/source/iodev/harddrv.cc#L2821 if(this.drive_head & 0x10) { // slave this.data_allocate(0); return; } for(var i = 0; i < 512; i++) { this.data[i] = 0; } var cylinder_count = Math.min(16383, this.cylinder_count); this.data_set([ 0x40, this.is_atapi ? 0x85 : 0, // 1 cylinders cylinder_count, cylinder_count >> 8, 0, 0, // 3 heads this.head_count, this.head_count >> 8, this.sectors_per_track / 512, this.sectors_per_track / 512 >> 8, // 5 0, 512 >> 8, // sectors per track this.sectors_per_track, this.sectors_per_track >> 8, 0, 0, 0, 0, 0, 0, // 10-19 serial number 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 15 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20 3, 0, 0, 2, 4, 0, // 23-26 firmware revision 0, 0, 0, 0, 0, 0, 0, 0, // 27 model number 56, 118, 32, 54, 68, 72, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, // 47 max value for set multiple mode 0x80, 0, 1, 0, //0, 3, // capabilities, 2: Only LBA / 3: LBA and DMA 0, 2, // capabilities, 2: Only LBA / 3: LBA and DMA // 50 0, 0, 0, 2, 0, 2, 7, 0, // 54 cylinders cylinder_count, cylinder_count >> 8, // 55 heads this.head_count, this.head_count >> 8, // 56 sectors per track this.sectors_per_track, 0, // capacity in sectors this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF, this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF, 0, 0, // 60 this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF, this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF, 0, 0, // 63, dma supported mode, dma selected mode this.current_command === 0xA0 ? 0 : 7, this.current_command === 0xA0 ? 0 : 4, //0, 0, // no DMA 0, 0, // 65 30, 0, 30, 0, 30, 0, 30, 0, 0, 0, // 70 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 75 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80 0x7E, 0, 0, 0, 0, 0, 0, 0x74, 0, 0x40, // 85 0, 0x40, 0, 0x74, 0, 0x40, 0, 0, 0, 0, // 90 0, 0, 0, 0, 0, 0, 1, 0x60, 0, 0, // 95 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 100 this.sector_count & 0xFF, this.sector_count >> 8 & 0xFF, this.sector_count >> 16 & 0xFF, this.sector_count >> 24 & 0xFF, ]); this.data_length = 512; this.data_end = 512; }; IDEInterface.prototype.data_allocate = function(len) { this.data_allocate_noclear(len); for(var i = 0; i < (len + 3 >> 2); i++) { this.data32[i] = 0; } }; IDEInterface.prototype.data_allocate_noclear = function(len) { if(this.data.length < len) { this.data = new Uint8Array(len + 3 & ~3); this.data16 = new Uint16Array(this.data.buffer); this.data32 = new Int32Array(this.data.buffer); } this.data_length = len; this.data_pointer = 0; }; IDEInterface.prototype.data_set = function(data) { this.data_allocate_noclear(data.length); this.data.set(data); }; IDEInterface.prototype.report_read_start = function() { this.stats.loading = true; this.bus.send("ide-read-start"); }; IDEInterface.prototype.report_read_end = function(byte_count) { this.stats.loading = false; var sector_count = byte_count / this.sector_size | 0; this.stats.sectors_read += sector_count; this.stats.bytes_read += byte_count; this.bus.send("ide-read-end", [this.nr, byte_count, sector_count]); }; IDEInterface.prototype.report_write = function(byte_count) { var sector_count = byte_count / this.sector_size | 0; this.stats.sectors_written += sector_count; this.stats.bytes_written += byte_count; this.bus.send("ide-write-end", [this.nr, byte_count, sector_count]); }; IDEInterface.prototype.read_buffer = function(start, length, callback) { const id = this.last_io_id++; this.in_progress_io_ids.add(id); this.buffer.get(start, length, data => { if(this.cancelled_io_ids.delete(id)) { dbg_assert(!this.in_progress_io_ids.has(id)); return; } const removed = this.in_progress_io_ids.delete(id); dbg_assert(removed); callback(data); }); }; IDEInterface.prototype.cancel_io_operations = function() { for(const id of this.in_progress_io_ids) { this.cancelled_io_ids.add(id); } this.in_progress_io_ids.clear(); }; IDEInterface.prototype.get_state = function() { var state = []; state[0] = this.bytecount; state[1] = this.cylinder_count; state[2] = this.cylinder_high; state[3] = this.cylinder_low; state[4] = this.data_pointer; state[5] = 0; state[6] = 0; state[7] = 0; state[8] = 0; state[9] = this.drive_head; state[10] = this.error; state[11] = this.head; state[12] = this.head_count; state[13] = this.is_atapi; state[14] = this.is_lba; state[15] = this.lba_count; state[16] = this.data; state[17] = this.data_length; state[18] = this.sector; state[19] = this.sector_count; state[20] = this.sector_size; state[21] = this.sectors_per_drq; state[22] = this.sectors_per_track; state[23] = this.status; state[24] = this.write_dest; state[25] = this.current_command; state[26] = this.data_end; state[27] = this.current_atapi_command; state[28] = this.buffer; return state; }; IDEInterface.prototype.set_state = function(state) { this.bytecount = state[0]; this.cylinder_count = state[1]; this.cylinder_high = state[2]; this.cylinder_low = state[3]; this.data_pointer = state[4]; this.drive_head = state[9]; this.error = state[10]; this.head = state[11]; this.head_count = state[12]; this.is_atapi = state[13]; this.is_lba = state[14]; this.lba_count = state[15]; this.data = state[16]; this.data_length = state[17]; this.sector = state[18]; this.sector_count = state[19]; this.sector_size = state[20]; this.sectors_per_drq = state[21]; this.sectors_per_track = state[22]; this.status = state[23]; this.write_dest = state[24]; this.current_command = state[25]; this.data_end = state[26]; this.current_atapi_command = state[27]; this.data16 = new Uint16Array(this.data.buffer); this.data32 = new Int32Array(this.data.buffer); this.buffer && this.buffer.set_state(state[28]); };