#include "ide-types.h"
#include "atapi-types.h"
-#ifndef CONFIG_DEBUG_IDE
+#ifndef V3_CONFIG_DEBUG_IDE
#undef PrintDebug
#define PrintDebug(fmt, args...)
#endif
};
struct ide_hd_state {
- int accessed;
+ uint32_t accessed;
/* this is the multiple sector transfer size as configured for read/write multiple sectors*/
- uint_t mult_sector_num;
+ uint32_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;
+ uint32_t cur_sector_num;
};
struct ide_drive {
char model[41];
// Where we are in the data transfer
- uint_t transfer_index;
+ uint32_t transfer_index;
// the length of a transfer
// calculated for easy access
- uint_t transfer_length;
+ uint32_t transfer_length;
uint64_t current_lba;
// Control Registers
struct ide_ctrl_reg ctrl_reg; // [write] 0x3f6,0x376
- struct ide_dma_cmd_reg dma_cmd;
- struct ide_dma_status_reg dma_status;
- uint32_t dma_prd_addr;
- uint_t dma_tbl_index;
+ union {
+ uint8_t dma_ports[8];
+ struct {
+ struct ide_dma_cmd_reg dma_cmd;
+ uint8_t rsvd1;
+ struct ide_dma_status_reg dma_status;
+ uint8_t rsvd2;
+ uint32_t dma_prd_addr;
+ } __attribute__((packed));
+ } __attribute__((packed));
+
+ uint32_t dma_tbl_index;
};
/* Drive Commands */
static void ide_raise_irq(struct ide_internal * ide, struct ide_channel * channel) {
if (channel->ctrl_reg.irq_disable == 0) {
- // PrintError("Raising IDE Interrupt %d\n", channel->irq);
+
+ //PrintError("Raising IDE Interrupt %d\n", channel->irq);
+
channel->dma_status.int_gen = 1;
v3_raise_irq(ide->vm, channel->irq);
}
#include "ata.h"
-#ifdef CONFIG_DEBUG_IDE
+
static void print_prd_table(struct ide_internal * ide, struct ide_channel * channel) {
struct ide_dma_prd prd_entry;
int index = 0;
- PrintDebug("Dumping PRD table\n");
+ V3_Print("Dumping PRD table\n");
while (1) {
uint32_t prd_entry_addr = channel->dma_prd_addr + (sizeof(struct ide_dma_prd) * index);
return;
}
- PrintDebug("\tPRD Addr: %x, PRD Len: %d, EOT: %d\n",
- prd_entry.base_addr, prd_entry.size, prd_entry.end_of_table);
+ V3_Print("\tPRD Addr: %x, PRD Len: %d, EOT: %d\n",
+ prd_entry.base_addr,
+ (prd_entry.size == 0) ? 0x10000 : prd_entry.size,
+ prd_entry.end_of_table);
if (prd_entry.end_of_table) {
break;
return;
}
-#endif
+
/* IO Operations */
static int dma_read(struct guest_info * core, struct ide_internal * ide, struct ide_channel * channel) {
// Read in the data buffer....
// Read a sector/block at a time until the prd entry is full.
-#ifdef CONFIG_DEBUG_IDE
+#ifdef V3_CONFIG_DEBUG_IDE
print_prd_table(ide, channel);
#endif
// loop through the PRD data....
- prd_bytes_left = prd_entry.size;
+ if (prd_entry.size == 0) {
+ // a size of 0 means 64k
+ prd_bytes_left = 0x10000;
+ } else {
+ prd_bytes_left = prd_entry.size;
+ }
while (prd_bytes_left > 0) {
return -1;
}
} else {
- PrintDebug("DMA of command packet\n");
- PrintError("How does this work???\n");
+ /*
+ PrintError("How does this work (ATAPI CMD=%x)???\n", drive->cd_state.atapi_cmd);
return -1;
+ */
+ int cmd_ret = 0;
+
+ //V3_Print("DMA of command packet\n");
+
bytes_to_write = (prd_bytes_left > bytes_left) ? bytes_left : prd_bytes_left;
prd_bytes_left = bytes_to_write;
+
+
+ // V3_Print("Writing ATAPI cmd OP DMA (cmd=%x) (len=%d)\n", drive->cd_state.atapi_cmd, prd_bytes_left);
+ cmd_ret = v3_write_gpa_memory(core, prd_entry.base_addr + prd_offset,
+ bytes_to_write, drive->data_buf);
+
+ // check cmd_ret
+
+
+ bytes_to_write = 0;
+ prd_bytes_left = 0;
+ drive->transfer_index += bytes_to_write;
+
+ channel->status.busy = 0;
+ channel->status.ready = 1;
+ channel->status.data_req = 0;
+ channel->status.error = 0;
+ channel->status.seek_complete = 1;
+
+ channel->dma_status.active = 0;
+ channel->dma_status.err = 0;
+
+ ide_raise_irq(ide, channel);
+
+ return 0;
}
}
PrintDebug("PRD Addr: %x, PRD Len: %d, EOT: %d\n",
prd_entry.base_addr, prd_entry.size, prd_entry.end_of_table);
- prd_bytes_left = prd_entry.size;
+
+ if (prd_entry.size == 0) {
+ // a size of 0 means 64k
+ prd_bytes_left = 0x10000;
+ } else {
+ prd_bytes_left = prd_entry.size;
+ }
while (prd_bytes_left > 0) {
uint_t bytes_to_write = 0;
if ((prd_entry.end_of_table == 1) && (bytes_left > 0)) {
PrintError("DMA table not large enough for data transfer...\n");
+ PrintError("\t(bytes_left=%u) (transfer_length=%u)...\n",
+ bytes_left, drive->transfer_length);
+ PrintError("PRD Addr: %x, PRD Len: %d, EOT: %d\n",
+ prd_entry.base_addr, prd_entry.size, prd_entry.end_of_table);
+
+ print_prd_table(ide, channel);
return -1;
}
}
break;
}
default:
- PrintError("IDE: Invalid DMA Port (%s)\n", dma_port_to_str(port_offset));
- return -1;
+ PrintError("IDE: Invalid DMA Port (%d) (%s)\n", port, dma_port_to_str(port_offset));
+ break;
}
return length;
}
-static int read_dma_port(struct guest_info * core, ushort_t port, void * dst, uint_t length, void * private_data) {
+static int read_dma_port(struct guest_info * core, uint16_t port, void * dst, uint_t length, void * private_data) {
struct ide_internal * ide = (struct ide_internal *)private_data;
uint16_t port_offset = port & (DMA_CHANNEL_FLAG - 1);
uint_t channel_flag = (port & DMA_CHANNEL_FLAG) >> 3;
PrintDebug("Reading DMA port %d (%x) (channel=%d)\n", port, port, channel_flag);
- switch (port_offset) {
- case DMA_CMD_PORT:
- *(uint8_t *)dst = channel->dma_cmd.val;
- break;
-
- case DMA_STATUS_PORT:
- if (length != 1) {
- PrintError("Invalid read length for DMA status port\n");
- return -1;
- }
-
- *(uint8_t *)dst = channel->dma_status.val;
- break;
-
- case DMA_PRD_PORT0:
- case DMA_PRD_PORT1:
- case DMA_PRD_PORT2:
- case DMA_PRD_PORT3: {
- uint_t addr_index = port_offset & 0x3;
- uint8_t * addr_buf = (uint8_t *)&(channel->dma_prd_addr);
- int i = 0;
-
- if (addr_index + length > 4) {
- PrintError("DMA Port space overrun port=%x len=%d\n", port_offset, length);
- return -1;
- }
-
- for (i = 0; i < length; i++) {
- *((uint8_t *)dst + i) = addr_buf[addr_index + i];
- }
-
- break;
- }
- default:
- PrintError("IDE: Invalid DMA Port (%s)\n", dma_port_to_str(port_offset));
- return -1;
+ if (port_offset + length > 16) {
+ PrintError("DMA Port Read: Port overrun (port_offset=%d, length=%d)\n", port_offset, length);
+ return -1;
}
+ memcpy(dst, channel->dma_ports + port_offset, length);
+
PrintDebug("\tval=%x (len=%d)\n", *(uint32_t *)dst, length);
return length;
channel->status.error = 0;
break;
+ case 0xe5: // Check power mode
+ drive->sector_count = 0xff; /* 0x00=standby, 0x80=idle, 0xff=active or idle */
+ channel->status.busy = 0;
+ channel->status.ready = 1;
+ channel->status.write_fault = 0;
+ channel->status.data_req = 0;
+ channel->status.error = 0;
+ break;
+
case 0xc4: // read multiple sectors
drive->hd_state.cur_sector_num = drive->hd_state.mult_sector_num;
default:
static int read_cd_data(uint8_t * dst, uint_t length, struct ide_internal * ide, struct ide_channel * channel) {
struct ide_drive * drive = get_selected_drive(channel);
int data_offset = drive->transfer_index % ATAPI_BLOCK_SIZE;
- int req_offset = drive->transfer_index % drive->req_len;
+ // int req_offset = drive->transfer_index % drive->req_len;
if (drive->cd_state.atapi_cmd != 0x28) {
PrintDebug("IDE: Reading CD Data (len=%d) (req_len=%d)\n", length, drive->req_len);
+ PrintDebug("IDE: transfer len=%d, transfer idx=%d\n", drive->transfer_length, drive->transfer_index);
}
+
+
if (drive->transfer_index >= drive->transfer_length) {
PrintError("Buffer Overrun... (xfer_len=%d) (cur_idx=%d) (post_idx=%d)\n",
drive->transfer_length, drive->transfer_index,
// Should the req_offset be recalculated here?????
- if ((req_offset == 0) && (drive->transfer_index > 0)) {
+ if (/*(req_offset == 0) &&*/ (drive->transfer_index > 0)) {
if (drive->transfer_index < drive->transfer_length) {
// An increment is complete, but there is still more data to be transferred...
}
} else {
// This was the final read of the request
+
+ drive->req_len = 0;
channel->status.data_req = 0;
channel->status.ready = 1;
struct ide_channel * channel = get_selected_channel(ide, port);
struct ide_drive * drive = get_selected_drive(channel);
- PrintDebug("IDE: Reading Data Port %x (len=%d)\n", port, length);
+ // PrintDebug("IDE: Reading Data Port %x (len=%d)\n", port, length);
if ((channel->cmd_reg == 0xec) ||
(channel->cmd_reg == 0xa1)) {
if (drive->drive_type == BLOCK_CDROM) {
if (read_cd_data((uint8_t *)dst, length, ide, channel) == -1) {
- PrintError("IDE: Could not read CD Data\n");
+ PrintError("IDE: Could not read CD Data (atapi cmd=%x)\n", drive->cd_state.atapi_cmd);
return -1;
}
} else if (drive->drive_type == BLOCK_DISK) {
PrintDebug("Attempting to select a non-present drive\n");
channel->error_reg.abort = 1;
channel->status.error = 1;
+ } else {
+ channel->status.busy = 0;
+ channel->status.ready = 1;
+ channel->status.data_req = 0;
+ channel->status.error = 0;
+ channel->status.seek_complete = 1;
+
+ channel->dma_status.active = 0;
+ channel->dma_status.err = 0;
}
break;
channel->cmd_reg = 0x00;
channel->ctrl_reg.val = 0x08;
-
channel->dma_cmd.val = 0;
channel->dma_status.val = 0;
channel->dma_prd_addr = 0;
}
-static int pci_config_update(uint_t reg_num, void * src, uint_t length, void * private_data) {
+static int pci_config_update(struct pci_device * pci_dev, uint32_t reg_num, void * src, uint_t length, void * private_data) {
PrintDebug("PCI Config Update\n");
/*
struct ide_internal * ide = (struct ide_internal *)(private_data);
return 0;
}
+#ifdef V3_CONFIG_CHECKPOINT
+
+#include <palacios/vmm_sprintf.h>
+
+static int ide_save_extended(struct v3_chkpt *chkpt, char *id, void * private_data) {
+ struct ide_internal * ide = (struct ide_internal *)private_data;
+ struct v3_chkpt_ctx *ctx=0;
+ int ch_num = 0;
+ int drive_num = 0;
+ char buf[128];
+
+
+ ctx=v3_chkpt_open_ctx(chkpt,id);
+
+ if (!ctx) {
+ PrintError("Failed to open context for save\n");
+ goto savefailout;
+ }
+
+ // nothing saved yet
+
+ v3_chkpt_close_ctx(ctx);ctx=0;
+
+
+ for (ch_num = 0; ch_num < 2; ch_num++) {
+ struct ide_channel * ch = &(ide->channels[ch_num]);
+
+ snprintf(buf, 128, "%s-%d", id, ch_num);
+
+ ctx = v3_chkpt_open_ctx(chkpt, buf);
+
+ if (!ctx) {
+ PrintError("Unable to open context to save channel %d\n",ch_num);
+ goto savefailout;
+ }
+
+ V3_CHKPT_SAVE(ctx, "ERROR", ch->error_reg.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "FEATURES", ch->features.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "DRIVE_HEAD", ch->drive_head.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "STATUS", ch->status.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "CMD_REG", ch->cmd_reg, savefailout);
+ V3_CHKPT_SAVE(ctx, "CTRL_REG", ch->ctrl_reg.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "DMA_CMD", ch->dma_cmd.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "DMA_STATUS", ch->dma_status.val, savefailout);
+ V3_CHKPT_SAVE(ctx, "PRD_ADDR", ch->dma_prd_addr, savefailout);
+ V3_CHKPT_SAVE(ctx, "DMA_TBL_IDX", ch->dma_tbl_index, savefailout);
+
+ v3_chkpt_close_ctx(ctx); ctx=0;
+
+ for (drive_num = 0; drive_num < 2; drive_num++) {
+ struct ide_drive * drive = &(ch->drives[drive_num]);
+
+ snprintf(buf, 128, "%s-%d-%d", id, ch_num, drive_num);
+
+ ctx = v3_chkpt_open_ctx(chkpt, buf);
+
+ if (!ctx) {
+ PrintError("Unable to open context to save drive %d\n",drive_num);
+ goto savefailout;
+ }
+
+ V3_CHKPT_SAVE(ctx, "DRIVE_TYPE", drive->drive_type, savefailout);
+ V3_CHKPT_SAVE(ctx, "SECTOR_COUNT", drive->sector_count, savefailout);
+ V3_CHKPT_SAVE(ctx, "SECTOR_NUM", drive->sector_num, savefailout);
+ V3_CHKPT_SAVE(ctx, "CYLINDER", drive->cylinder,savefailout);
+
+ V3_CHKPT_SAVE(ctx, "CURRENT_LBA", drive->current_lba, savefailout);
+ V3_CHKPT_SAVE(ctx, "TRANSFER_LENGTH", drive->transfer_length, savefailout);
+ V3_CHKPT_SAVE(ctx, "TRANSFER_INDEX", drive->transfer_index, savefailout);
+
+ V3_CHKPT_SAVE(ctx, "DATA_BUF", drive->data_buf, savefailout);
+
+
+ /* For now we'll just pack the type specific data at the end... */
+ /* We should probably add a new context here in the future... */
+ if (drive->drive_type == BLOCK_CDROM) {
+ V3_CHKPT_SAVE(ctx, "ATAPI_SENSE_DATA", drive->cd_state.sense.buf, savefailout);
+ V3_CHKPT_SAVE(ctx, "ATAPI_CMD", drive->cd_state.atapi_cmd, savefailout);
+ V3_CHKPT_SAVE(ctx, "ATAPI_ERR_RECOVERY", drive->cd_state.err_recovery.buf, savefailout);
+ } else if (drive->drive_type == BLOCK_DISK) {
+ V3_CHKPT_SAVE(ctx, "ACCESSED", drive->hd_state.accessed, savefailout);
+ V3_CHKPT_SAVE(ctx, "MULT_SECT_NUM", drive->hd_state.mult_sector_num, savefailout);
+ V3_CHKPT_SAVE(ctx, "CUR_SECT_NUM", drive->hd_state.cur_sector_num, savefailout);
+ } else if (drive->drive_type == BLOCK_NONE) {
+ // no drive connected, so no data
+ } else {
+ PrintError("Invalid drive type %d\n",drive->drive_type);
+ goto savefailout;
+ }
+
+ v3_chkpt_close_ctx(ctx); ctx=0;
+ }
+ }
+
+// goodout:
+ return 0;
+
+ savefailout:
+ PrintError("Failed to save IDE\n");
+ if (ctx) {v3_chkpt_close_ctx(ctx); }
+ return -1;
+}
+
+
+
+static int ide_load_extended(struct v3_chkpt *chkpt, char *id, void * private_data) {
+ struct ide_internal * ide = (struct ide_internal *)private_data;
+ struct v3_chkpt_ctx *ctx=0;
+ int ch_num = 0;
+ int drive_num = 0;
+ char buf[128];
+
+ ctx=v3_chkpt_open_ctx(chkpt,id);
+
+ if (!ctx) {
+ PrintError("Failed to open context for load\n");
+ goto loadfailout;
+ }
+
+ // nothing saved yet
+
+ v3_chkpt_close_ctx(ctx);ctx=0;
+
+
+ for (ch_num = 0; ch_num < 2; ch_num++) {
+ struct ide_channel * ch = &(ide->channels[ch_num]);
+
+ snprintf(buf, 128, "%s-%d", id, ch_num);
+
+ ctx = v3_chkpt_open_ctx(chkpt, buf);
+
+ if (!ctx) {
+ PrintError("Unable to open context to load channel %d\n",ch_num);
+ goto loadfailout;
+ }
+
+ V3_CHKPT_LOAD(ctx, "ERROR", ch->error_reg.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "FEATURES", ch->features.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "DRIVE_HEAD", ch->drive_head.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "STATUS", ch->status.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "CMD_REG", ch->cmd_reg, loadfailout);
+ V3_CHKPT_LOAD(ctx, "CTRL_REG", ch->ctrl_reg.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "DMA_CMD", ch->dma_cmd.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "DMA_STATUS", ch->dma_status.val, loadfailout);
+ V3_CHKPT_LOAD(ctx, "PRD_ADDR", ch->dma_prd_addr, loadfailout);
+ V3_CHKPT_LOAD(ctx, "DMA_TBL_IDX", ch->dma_tbl_index, loadfailout);
+
+ v3_chkpt_close_ctx(ctx); ctx=0;
+
+ for (drive_num = 0; drive_num < 2; drive_num++) {
+ struct ide_drive * drive = &(ch->drives[drive_num]);
+
+ snprintf(buf, 128, "%s-%d-%d", id, ch_num, drive_num);
+
+ ctx = v3_chkpt_open_ctx(chkpt, buf);
+
+ if (!ctx) {
+ PrintError("Unable to open context to load drive %d\n",drive_num);
+ goto loadfailout;
+ }
+
+ V3_CHKPT_LOAD(ctx, "DRIVE_TYPE", drive->drive_type, loadfailout);
+ V3_CHKPT_LOAD(ctx, "SECTOR_COUNT", drive->sector_count, loadfailout);
+ V3_CHKPT_LOAD(ctx, "SECTOR_NUM", drive->sector_num, loadfailout);
+ V3_CHKPT_LOAD(ctx, "CYLINDER", drive->cylinder,loadfailout);
+
+ V3_CHKPT_LOAD(ctx, "CURRENT_LBA", drive->current_lba, loadfailout);
+ V3_CHKPT_LOAD(ctx, "TRANSFER_LENGTH", drive->transfer_length, loadfailout);
+ V3_CHKPT_LOAD(ctx, "TRANSFER_INDEX", drive->transfer_index, loadfailout);
+
+ V3_CHKPT_LOAD(ctx, "DATA_BUF", drive->data_buf, loadfailout);
+
+
+ /* For now we'll just pack the type specific data at the end... */
+ /* We should probably add a new context here in the future... */
+ if (drive->drive_type == BLOCK_CDROM) {
+ V3_CHKPT_LOAD(ctx, "ATAPI_SENSE_DATA", drive->cd_state.sense.buf, loadfailout);
+ V3_CHKPT_LOAD(ctx, "ATAPI_CMD", drive->cd_state.atapi_cmd, loadfailout);
+ V3_CHKPT_LOAD(ctx, "ATAPI_ERR_RECOVERY", drive->cd_state.err_recovery.buf, loadfailout);
+ } else if (drive->drive_type == BLOCK_DISK) {
+ V3_CHKPT_LOAD(ctx, "ACCESSED", drive->hd_state.accessed, loadfailout);
+ V3_CHKPT_LOAD(ctx, "MULT_SECT_NUM", drive->hd_state.mult_sector_num, loadfailout);
+ V3_CHKPT_LOAD(ctx, "CUR_SECT_NUM", drive->hd_state.cur_sector_num, loadfailout);
+ } else if (drive->drive_type == BLOCK_NONE) {
+ // no drive connected, so no data
+ } else {
+ PrintError("Invalid drive type %d\n",drive->drive_type);
+ goto loadfailout;
+ }
+ }
+ }
+// goodout:
+ return 0;
+
+ loadfailout:
+ PrintError("Failed to load IDE\n");
+ if (ctx) {v3_chkpt_close_ctx(ctx); }
+ return -1;
+
+}
+
+
+
+#endif
+
static struct v3_device_ops dev_ops = {
.free = (int (*)(void *))ide_free,
-
+#ifdef V3_CONFIG_CHECKPOINT
+ .save_extended = ide_save_extended,
+ .load_extended = ide_load_extended
+#endif
};
return -1;
}
- strncpy(drive->model, model_str, sizeof(drive->model) - 1);
-
+ if (model_str != NULL) {
+ strncpy(drive->model, model_str, sizeof(drive->model) - 1);
+ }
+
if (strcasecmp(type_str, "cdrom") == 0) {
drive->drive_type = BLOCK_CDROM;
pci_dev = v3_pci_register_device(ide->pci_bus, PCI_STD_DEVICE, 0, sb_pci->dev_num, 1,
"PIIX3_IDE", bars,
- pci_config_update, NULL, NULL, ide);
+ pci_config_update, NULL, NULL, NULL, ide);
if (pci_dev == NULL) {
PrintError("Failed to register IDE BUS %d with PCI\n", i);
