* redistribute, and modify it as specified in the file "V3VEE_LICENSE".
*/
+#define MAX_MULT_SECTORS 255
+
static void ata_identify_device(struct ide_drive * drive) {
struct ide_drive_id * drive_id = (struct ide_drive_id *)(drive->data_buf);
// Drive Capacity (48 bit LBA)
drive_id->lba_capacity_2 = drive->hd_ops->get_capacity(drive->private_data);
- drive_id->rw_multiples = 0x80ff;
+ // lower byte is the maximum multiple sector size...
+ drive_id->rw_multiples = 0x8000 | MAX_MULT_SECTORS;
// words 64-70, 54-58 valid
drive_id->field_valid = 0x0007; // DMA + pkg cmd valid
}
-static int ata_read(struct vm_device * dev, struct ide_channel * channel) {
+static int ata_read(struct vm_device * dev, struct ide_channel * channel, uint8_t * dst, uint_t sect_cnt) {
struct ide_drive * drive = get_selected_drive(channel);
if (drive->hd_state.accessed == 0) {
drive->hd_state.accessed = 1;
}
- int ret = drive->hd_ops->read(drive->data_buf, 1, drive->current_lba, drive->private_data);
+ int ret = drive->hd_ops->read(dst, sect_cnt, drive->current_lba, drive->private_data);
if (ret == -1) {
PrintError("IDE: Error reading HD block (LBA=%p)\n", (void *)(addr_t)(drive->current_lba));
lba_addr.buf[2] = drive->lba2;
lba_addr.buf[3] = channel->drive_head.lba3;
- PrintDebug("LBA Address %d\n", drive->lba0);
- PrintDebug("sector_num %d\n", drive->sector_num);
-
if (lba_addr.addr + (sect_cnt * IDE_SECTOR_SIZE) >
drive->hd_ops->get_capacity(drive->private_data)) {
drive->current_lba = lba_addr.addr;
- if (ata_read(dev, channel) == -1) {
+ if (ata_read(dev, channel, drive->data_buf, 1) == -1) {
PrintError("Could not read disk sector\n");
return -1;
}
#define PRI_DEFAULT_DMA_PORT 0xc000
#define SEC_DEFAULT_DMA_PORT 0xc008
-
#define DATA_BUFFER_SIZE 2048
static const char * ide_pri_port_strs[] = {"PRI_DATA", "PRI_FEATURES", "PRI_SECT_CNT", "PRI_SECT_NUM",
struct ide_hd_state {
int accessed;
+
+ /* this is the multiple sector transfer size as configured for read/write multiple sectors*/
+ uint_t mult_sector_num;
+
+ /* This is the current op sector size:
+ * for multiple sector ops this equals mult_sector_num
+ * for standard ops this equals 1
+ */
+ uint_t cur_sector_num;
};
struct ide_drive {
uint32_t prd_entry_addr = channel->dma_prd_addr + (sizeof(struct ide_dma_prd) * channel->dma_tbl_index);
int ret;
-
PrintDebug("PRD table address = %x\n", channel->dma_prd_addr);
ret = read_guest_pa_memory(dev->vm, prd_entry_addr, sizeof(struct ide_dma_prd), (void *)&prd_entry);
return -1;
}
- channel->status.busy = 0;
- channel->status.ready = 1;
- channel->status.data_req = 0;
- channel->status.error = 0;
- channel->status.seek_complete = 1;
+
/*
drive->irq_flags.io_dir = 1;
// set DMA status
- channel->dma_status.active = 0;
- channel->dma_status.err = 1;
- channel->dma_status.int_gen = 1;
+
+ if (prd_entry.end_of_table) {
+ channel->dma_status.active = 0;
+ channel->dma_status.err = 0;
+ channel->dma_status.int_gen = 1;
+
+ channel->status.busy = 0;
+ channel->status.ready = 1;
+ channel->status.data_req = 0;
+ channel->status.error = 0;
+ channel->status.seek_complete = 1;
+ }
ide_raise_irq(dev, channel);
return -1;
}
}
+
+ channel->dma_cmd.val &= 0x09;
}
break;
case 0x20: // Read Sectors with Retry
case 0x21: // Read Sectors without Retry
+ drive->hd_state.cur_sector_num = 1;
+
if (ata_read_sectors(dev, channel) == -1) {
PrintError("Error reading sectors\n");
return -1;
break;
case 0x24: // Read Sectors Extended
+ drive->hd_state.cur_sector_num = 1;
+
if (ata_read_sectors_ext(dev, channel) == -1) {
PrintError("Error reading extended sectors\n");
return -1;
}
break;
+
+ case 0xc8: // Read DMA with retry
+ case 0xc9: // Read DMA
+ drive->hd_state.cur_sector_num = 1;
+
+ break;
case 0xef: // Set Features
// Prior to this the features register has been written to.
// This command tells the drive to check if the new value is supported (the value is drive specific)
ide_raise_irq(dev, channel);
break;
+ case 0x91: // Initialize Drive Parameters
+ case 0x10: // recalibrate?
+ channel->status.error = 0;
+ channel->status.ready = 1;
+ channel->status.seek_complete = 1;
+ ide_raise_irq(dev, channel);
+ break;
+ case 0xc6: { // Set multiple mode (IDE Block mode)
+ // This makes the drive transfer multiple sectors before generating an interrupt
+ uint32_t tmp_sect_num = drive->sector_num; // GCC SUCKS
+
+ if (tmp_sect_num > MAX_MULT_SECTORS) {
+ ide_abort_command(dev, channel);
+ break;
+ }
+
+ if (drive->sector_count == 0) {
+ drive->hd_state.mult_sector_num= 1;
+ } else {
+ drive->hd_state.mult_sector_num = drive->sector_count;
+ }
+
+ channel->status.ready = 1;
+ channel->status.error = 0;
+
+ ide_raise_irq(dev, channel);
+
+ break;
+ }
+ case 0xc4: // read multiple sectors
+ drive->hd_state.cur_sector_num = drive->hd_state.mult_sector_num;
default:
PrintError("Unimplemented IDE command (%x)\n", channel->cmd_reg);
return -1;
if ((data_offset == 0) && (drive->transfer_index > 0)) {
drive->current_lba++;
- if (ata_read(dev, channel) == -1) {
+ if (ata_read(dev, channel, drive->data_buf, 1) == -1) {
PrintError("Could not read next disk sector\n");
return -1;
}
drive->transfer_index += length;
- if ((drive->transfer_index % IDE_SECTOR_SIZE) == 0) {
+
+ /* This is the trigger for interrupt injection.
+ * For read single sector commands we interrupt after every sector
+ * For multi sector reads we interrupt only at end of the cluster size (mult_sector_num)
+ * cur_sector_num is configured depending on the operation we are currently running
+ * We also trigger an interrupt if this is the last byte to transfer, regardless of sector count
+ */
+ if (((drive->transfer_index % (IDE_SECTOR_SIZE * drive->hd_state.cur_sector_num)) == 0) ||
+ (drive->transfer_index == drive->transfer_length)) {
if (drive->transfer_index < drive->transfer_length) {
// An increment is complete, but there is still more data to be transferred...
PrintDebug("Integral Complete, still transferring more sectors\n");
static int pci_config_update(struct pci_device * pci_dev, uint_t reg_num, int length) {
- PrintDebug("Interupt register (Dev=%s), irq=%d\n", pci_dev->name, pci_dev->config_header.intr_line);
+ PrintDebug("PCI Config Update\n");
+ PrintDebug("\t\tInterupt register (Dev=%s), irq=%d\n", pci_dev->name, pci_dev->config_header.intr_line);
return 0;
}
drive->drive_type = IDE_DISK;
drive->hd_state.accessed = 0;
+ drive->hd_state.mult_sector_num = 1;
drive->hd_ops = ops;
#include <devices/os_debug.h>
#include <palacios/vmm.h>
+#include <palacios/vm_guest_mem.h>
#define BUF_SIZE 1024
#define DEBUG_PORT1 0xc0c0
-
+#define DEBUG_HCALL 0xc0c0
struct debug_state {
char debug_buf[BUF_SIZE];
return length;
}
+static int handle_hcall(struct guest_info * info, uint_t hcall_id, void * priv_data) {
+ struct vm_device * dev = (struct vm_device *)priv_data;
+ struct debug_state * state = (struct debug_state *)dev->private_data;
+
+ int msg_len = info->vm_regs.rcx;
+ addr_t msg_gpa = info->vm_regs.rbx;
+
+ if (msg_len >= BUF_SIZE) {
+ PrintError("Console message too large for buffer (len=%d)\n", msg_len);
+ return -1;
+ }
+
+ if (read_guest_pa_memory(info, msg_gpa, msg_len, (uchar_t *)state->debug_buf) != msg_len) {
+ PrintError("Could not read debug message\n");
+ return -1;
+ }
+
+ state->debug_buf[msg_len] = 0;
+
+ PrintDebug("VM_CONSOLE>%s\n", state->debug_buf);
+
+ return 0;
+}
+
static int debug_init(struct vm_device * dev) {
struct debug_state * state = (struct debug_state *)dev->private_data;
v3_dev_hook_io(dev, DEBUG_PORT1, NULL, &handle_gen_write);
+ v3_register_hypercall(dev->vm, DEBUG_HCALL, handle_hcall, dev);
state->debug_offset = 0;
memset(state->debug_buf, 0, BUF_SIZE);
if ((info->intr_state.irq_pending == 1) && (guest_ctrl->guest_ctrl.V_IRQ == 0)) {
// Interrupt was taken in the guest
+ if (exit_code == VMEXIT_EXCP14) {
+ PrintError("Page fault immeidately after interrupt injection (%d)\n", info->intr_state.irq_vector);
+ }
+
#ifdef DEBUG_INTERRUPTS
PrintDebug("Interrupt %d taken by guest\n", info->intr_state.irq_vector);
#endif
if (!guest_ctrl->exit_int_info.valid) {
+ info->intr_state.irq_pending = 0;
+ // PrintDebug("Injecting Interrupt %d\n", info->intr_state.irq_vector);
v3_injecting_intr(info, info->intr_state.irq_vector, EXTERNAL_IRQ);
} else {
#ifdef DEBUG_INTERRUPTS
}
}
- info->intr_state.irq_pending = 0;
+
// Disable printing io exits due to bochs debug messages
// Update the low level state
+ if (info->intr_state.irq_pending == 1) {
+
+ guest_ctrl->guest_ctrl.V_IRQ = 1;
+ guest_ctrl->guest_ctrl.V_INTR_VECTOR = info->intr_state.irq_vector;
+ guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
+ guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
- if (v3_excp_pending(info)) {
+ } else if (v3_excp_pending(info)) {
uint_t excp = v3_get_excp_number(info);
guest_ctrl->EVENTINJ.type = SVM_INJECTION_EXCEPTION;
static int setup_devices(struct guest_info * info, struct v3_vm_config * config_ptr) {
struct vm_device * ide = NULL;
- // struct vm_device * ram_cd = NULL;
+ //struct vm_device * ram_cd = NULL;
struct vm_device * ram_hd = NULL;
struct vm_device * pci = v3_create_pci();
struct vm_device * nvram = v3_create_nvram();
if (use_ramdisk) {
PrintDebug("Creating Ramdisk\n");
- // ram_cd = v3_create_ram_cd(ide, 0, 0,
- // (addr_t)(config_ptr->ramdisk),
- // config_ptr->ramdisk_size);
+ //ram_cd = v3_create_ram_cd(ide, 0, 0,
+ // (addr_t)(config_ptr->ramdisk),
+ // config_ptr->ramdisk_size);
ram_hd = v3_create_ram_hd(ide, 0, 0,
(addr_t)(config_ptr->ramdisk),
config_ptr->ramdisk_size);
v3_attach_device(info, ide);
if (use_ramdisk) {
- // v3_attach_device(info, ram_cd);
+ // v3_attach_device(info, ram_cd);
v3_attach_device(info, ram_hd);
}
