#include "ide-types.h"
#include "atapi-types.h"
-#ifndef CONFIG_DEBUG_IDE
+#ifndef V3_CONFIG_DEBUG_IDE
#undef PrintDebug
#define PrintDebug(fmt, args...)
#endif
#include "ata.h"
-#ifdef CONFIG_DEBUG_IDE
-static void print_prd_table(struct vm_device * dev, struct ide_channel * channel) {
+#ifdef V3_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;
uint32_t prd_entry_addr = channel->dma_prd_addr + (sizeof(struct ide_dma_prd) * index);
int ret;
- ret = v3_read_gpa_memory(&(dev->vm->cores[0]), prd_entry_addr, sizeof(struct ide_dma_prd), (void *)&prd_entry);
+ ret = v3_read_gpa_memory(&(ide->vm->cores[0]), prd_entry_addr, sizeof(struct ide_dma_prd), (void *)&prd_entry);
if (ret != sizeof(struct ide_dma_prd)) {
PrintError("Could not read PRD\n");
}
PrintDebug("\tPRD Addr: %x, PRD Len: %d, EOT: %d\n",
- prd_entry.base_addr, prd_entry.size, prd_entry.end_of_table);
+ prd_entry.base_addr,
+ (prd_entry.size == 0) ? 0x10000 : prd_entry.size,
+ prd_entry.end_of_table);
if (prd_entry.end_of_table) {
break;
// 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("DMA of command packet\n");
+ PrintError("How does this work (ATAPI CMD=%x)???\n", drive->cd_state.atapi_cmd);
return -1;
+ */
+ int cmd_ret = 0;
+
bytes_to_write = (prd_bytes_left > bytes_left) ? bytes_left : prd_bytes_left;
prd_bytes_left = bytes_to_write;
+
+ 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;
}
}
break;
}
+
+ case 0x08: // Reset Device
+ drive_reset(drive);
+ channel->error_reg.val = 0x01;
+ channel->status.busy = 0;
+ channel->status.ready = 1;
+ channel->status.seek_complete = 1;
+ channel->status.write_fault = 0;
+ 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;
static int pci_config_update(uint_t reg_num, void * src, uint_t length, void * private_data) {
PrintDebug("PCI Config Update\n");
- /* struct vm_device * dev = (struct vm_device *)private_data;
- struct ide_internal * ide = (struct ide_internal *)(dev->private_data);
+ /*
+ struct ide_internal * ide = (struct ide_internal *)(private_data);
PrintDebug("\t\tInterupt register (Dev=%s), irq=%d\n", ide->ide_pci->name, ide->ide_pci->config_header.intr_line);
*/
-static int ide_free(struct vm_device * dev) {
- // unhook io ports....
-
+static int ide_free(struct ide_internal * ide) {
// deregister from PCI?
-
+ V3_Free(ide);
return 0;
}
static struct v3_device_ops dev_ops = {
- .free = ide_free,
+ .free = (int (*)(void *))ide_free,
};
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;
static int ide_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
struct ide_internal * ide = NULL;
char * dev_id = v3_cfg_val(cfg, "ID");
+ int ret = 0;
PrintDebug("IDE: Initializing IDE\n");
memset(ide, 0, sizeof(struct ide_internal));
ide->vm = vm;
-
ide->pci_bus = v3_find_dev(vm, v3_cfg_val(cfg, "bus"));
if (ide->pci_bus != NULL) {
PrintDebug("IDE: Creating IDE bus x 2\n");
- struct vm_device * dev = v3_allocate_device(dev_id, &dev_ops, ide);
+ struct vm_device * dev = v3_add_device(vm, dev_id, &dev_ops, ide);
- if (v3_attach_device(vm, dev) == -1) {
+ if (dev == NULL) {
PrintError("Could not attach device %s\n", dev_id);
- v3_free_device(dev);
V3_Free(ide);
return -1;
}
if (init_ide_state(ide) == -1) {
PrintError("Failed to initialize IDE state\n");
- v3_detach_device(dev);
+ v3_remove_device(dev);
return -1;
}
PrintDebug("Connecting to IDE IO ports\n");
- v3_dev_hook_io(dev, PRI_DATA_PORT,
- &ide_read_data_port, &write_data_port);
- v3_dev_hook_io(dev, PRI_FEATURES_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_SECT_CNT_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_SECT_NUM_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_CYL_LOW_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_CYL_HIGH_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_DRV_SEL_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_CMD_PORT,
- &read_port_std, &write_cmd_port);
-
- v3_dev_hook_io(dev, SEC_DATA_PORT,
- &ide_read_data_port, &write_data_port);
- v3_dev_hook_io(dev, SEC_FEATURES_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_SECT_CNT_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_SECT_NUM_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_CYL_LOW_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_CYL_HIGH_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_DRV_SEL_PORT,
- &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_CMD_PORT,
- &read_port_std, &write_cmd_port);
+ ret |= v3_dev_hook_io(dev, PRI_DATA_PORT,
+ &ide_read_data_port, &write_data_port);
+ ret |= v3_dev_hook_io(dev, PRI_FEATURES_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_SECT_CNT_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_SECT_NUM_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_CYL_LOW_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_CYL_HIGH_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_DRV_SEL_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_CMD_PORT,
+ &read_port_std, &write_cmd_port);
+
+ ret |= v3_dev_hook_io(dev, SEC_DATA_PORT,
+ &ide_read_data_port, &write_data_port);
+ ret |= v3_dev_hook_io(dev, SEC_FEATURES_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_SECT_CNT_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_SECT_NUM_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_CYL_LOW_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_CYL_HIGH_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_DRV_SEL_PORT,
+ &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_CMD_PORT,
+ &read_port_std, &write_cmd_port);
- v3_dev_hook_io(dev, PRI_CTRL_PORT,
- &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_CTRL_PORT,
+ &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_CTRL_PORT,
- &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_CTRL_PORT,
+ &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, SEC_ADDR_REG_PORT,
- &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, SEC_ADDR_REG_PORT,
+ &read_port_std, &write_port_std);
- v3_dev_hook_io(dev, PRI_ADDR_REG_PORT,
- &read_port_std, &write_port_std);
+ ret |= v3_dev_hook_io(dev, PRI_ADDR_REG_PORT,
+ &read_port_std, &write_port_std);
+ if (ret != 0) {
+ PrintError("Error hooking IDE IO port\n");
+ v3_remove_device(dev);
+ return -1;
+ }
if (ide->pci_bus) {
bars[4].io_read = read_dma_port;
bars[4].io_write = write_dma_port;
- bars[4].private_data = dev;
+ bars[4].private_data = ide;
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, dev);
+ pci_config_update, NULL, NULL, ide);
if (pci_dev == NULL) {
PrintError("Failed to register IDE BUS %d with PCI\n", i);
+ v3_remove_device(dev);
return -1;
}
if (v3_dev_add_blk_frontend(vm, dev_id, connect_fn, (void *)ide) == -1) {
PrintError("Could not register %s as frontend\n", dev_id);
- v3_detach_device(dev);
+ v3_remove_device(dev);
return -1;
}
-int v3_ide_get_geometry(struct vm_device * ide_dev, int channel_num, int drive_num,
+int v3_ide_get_geometry(void * ide_data, int channel_num, int drive_num,
uint32_t * cylinders, uint32_t * heads, uint32_t * sectors) {
- struct ide_internal * ide = (struct ide_internal *)(ide_dev->private_data);
+ struct ide_internal * ide = ide_data;
struct ide_channel * channel = &(ide->channels[channel_num]);
struct ide_drive * drive = &(channel->drives[drive_num]);
