X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fdevices%2Fide.c;h=206a8effccd9ab8b36be93352072b9ddee473d9f;hb=94966f95239e03c7df97bd71d6be3e1316239d21;hp=3ef7d4da25964a3881a2765d531ec5d1f79b6c98;hpb=94f67717b6461df514dc225ed84f03b44c44061b;p=palacios.git diff --git a/palacios/src/devices/ide.c b/palacios/src/devices/ide.c index 3ef7d4d..206a8ef 100644 --- a/palacios/src/devices/ide.c +++ b/palacios/src/devices/ide.c @@ -110,16 +110,16 @@ struct ide_cd_state { }; 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 { @@ -137,11 +137,11 @@ 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; @@ -206,10 +206,18 @@ struct ide_channel { // 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; }; @@ -283,7 +291,9 @@ static inline int is_lba_enabled(struct ide_channel * channel) { /* 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); } @@ -356,12 +366,12 @@ static int dma_write(struct guest_info * core, struct ide_internal * ide, struct #include "ata.h" -#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; - 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); @@ -374,7 +384,7 @@ static void print_prd_table(struct ide_internal * ide, struct ide_channel * chan return; } - PrintDebug("\tPRD Addr: %x, PRD Len: %d, EOT: %d\n", + 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); @@ -388,7 +398,7 @@ static void print_prd_table(struct ide_internal * ide, struct ide_channel * chan return; } -#endif + /* IO Operations */ static int dma_read(struct guest_info * core, struct ide_internal * ide, struct ide_channel * channel) { @@ -456,15 +466,18 @@ static int dma_read(struct guest_info * core, struct ide_internal * ide, struct } } else { /* - 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; + //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); @@ -591,7 +604,13 @@ static int dma_write(struct guest_info * core, struct ide_internal * ide, struct 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; @@ -632,6 +651,12 @@ static int dma_write(struct guest_info * core, struct ide_internal * ide, struct 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; } } @@ -737,15 +762,15 @@ static int write_dma_port(struct guest_info * core, ushort_t port, void * src, u 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; @@ -753,44 +778,13 @@ static int read_dma_port(struct guest_info * core, ushort_t port, void * dst, ui 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; @@ -1314,6 +1308,15 @@ static int write_port_std(struct guest_info * core, ushort_t port, void * src, u 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; @@ -1444,7 +1447,6 @@ static void init_channel(struct ide_channel * channel) { channel->cmd_reg = 0x00; channel->ctrl_reg.val = 0x08; - channel->dma_cmd.val = 0; channel->dma_status.val = 0; channel->dma_prd_addr = 0; @@ -1457,7 +1459,7 @@ static void init_channel(struct ide_channel * channel) { } -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); @@ -1498,9 +1500,146 @@ static int ide_free(struct ide_internal * ide) { return 0; } +#ifdef V3_CONFIG_CHECKPOINT + +#include +static int ide_save(struct v3_chkpt_ctx * ctx, void * private_data) { + struct ide_internal * ide = (struct ide_internal *)private_data; + int ch_num = 0; + int drive_num = 0; + char buf[128]; + + + for (ch_num = 0; ch_num < 2; ch_num++) { + struct v3_chkpt_ctx * ch_ctx = NULL; + struct ide_channel * ch = &(ide->channels[ch_num]); + + snprintf(buf, 128, "channel-%d", ch_num); + ch_ctx = v3_chkpt_open_ctx(ctx->chkpt, ctx, buf); + + v3_chkpt_save_8(ch_ctx, "ERROR", &(ch->error_reg.val)); + v3_chkpt_save_8(ch_ctx, "FEATURES", &(ch->features.val)); + v3_chkpt_save_8(ch_ctx, "DRIVE_HEAD", &(ch->drive_head.val)); + v3_chkpt_save_8(ch_ctx, "STATUS", &(ch->status.val)); + v3_chkpt_save_8(ch_ctx, "CMD_REG", &(ch->cmd_reg)); + v3_chkpt_save_8(ch_ctx, "CTRL_REG", &(ch->ctrl_reg.val)); + v3_chkpt_save_8(ch_ctx, "DMA_CMD", &(ch->dma_cmd.val)); + v3_chkpt_save_8(ch_ctx, "DMA_STATUS", &(ch->dma_status.val)); + v3_chkpt_save_32(ch_ctx, "PRD_ADDR", &(ch->dma_prd_addr)); + v3_chkpt_save_32(ch_ctx, "DMA_TBL_IDX", &(ch->dma_tbl_index)); + + + for (drive_num = 0; drive_num < 2; drive_num++) { + struct v3_chkpt_ctx * drive_ctx = NULL; + struct ide_drive * drive = &(ch->drives[drive_num]); + + snprintf(buf, 128, "drive-%d-%d", ch_num, drive_num); + drive_ctx = v3_chkpt_open_ctx(ctx->chkpt, ch_ctx, buf); + + v3_chkpt_save_8(drive_ctx, "DRIVE_TYPE", &(drive->drive_type)); + v3_chkpt_save_8(drive_ctx, "SECTOR_COUNT", &(drive->sector_count)); + v3_chkpt_save_8(drive_ctx, "SECTOR_NUM", &(drive->sector_num)); + v3_chkpt_save_16(drive_ctx, "CYLINDER", &(drive->cylinder)); + + v3_chkpt_save_64(drive_ctx, "CURRENT_LBA", &(drive->current_lba)); + v3_chkpt_save_32(drive_ctx, "TRANSFER_LENGTH", &(drive->transfer_length)); + v3_chkpt_save_32(drive_ctx, "TRANSFER_INDEX", &(drive->transfer_index)); + + v3_chkpt_save(drive_ctx, "DATA_BUF", DATA_BUFFER_SIZE, drive->data_buf); + + + /* 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(drive_ctx, "ATAPI_SENSE_DATA", 18, drive->cd_state.sense.buf); + v3_chkpt_save_8(drive_ctx, "ATAPI_CMD", &(drive->cd_state.atapi_cmd)); + v3_chkpt_save(drive_ctx, "ATAPI_ERR_RECOVERY", 12, drive->cd_state.err_recovery.buf); + } else if (drive->drive_type == BLOCK_DISK) { + v3_chkpt_save_32(drive_ctx, "ACCESSED", &(drive->hd_state.accessed)); + v3_chkpt_save_32(drive_ctx, "MULT_SECT_NUM", &(drive->hd_state.mult_sector_num)); + v3_chkpt_save_32(drive_ctx, "CUR_SECT_NUM", &(drive->hd_state.cur_sector_num)); + } + } + } + + return 0; +} + + + +static int ide_load(struct v3_chkpt_ctx * ctx, void * private_data) { + struct ide_internal * ide = (struct ide_internal *)private_data; + int ch_num = 0; + int drive_num = 0; + char buf[128]; + + + for (ch_num = 0; ch_num < 2; ch_num++) { + struct v3_chkpt_ctx * ch_ctx = NULL; + struct ide_channel * ch = &(ide->channels[ch_num]); + + snprintf(buf, 128, "channel-%d", ch_num); + ch_ctx = v3_chkpt_open_ctx(ctx->chkpt, ctx, buf); + + v3_chkpt_load_8(ch_ctx, "ERROR", &(ch->error_reg.val)); + v3_chkpt_load_8(ch_ctx, "FEATURES", &(ch->features.val)); + v3_chkpt_load_8(ch_ctx, "DRIVE_HEAD", &(ch->drive_head.val)); + v3_chkpt_load_8(ch_ctx, "STATUS", &(ch->status.val)); + v3_chkpt_load_8(ch_ctx, "CMD_REG", &(ch->cmd_reg)); + v3_chkpt_load_8(ch_ctx, "CTRL_REG", &(ch->ctrl_reg.val)); + v3_chkpt_load_8(ch_ctx, "DMA_CMD", &(ch->dma_cmd.val)); + v3_chkpt_load_8(ch_ctx, "DMA_STATUS", &(ch->dma_status.val)); + v3_chkpt_load_32(ch_ctx, "PRD_ADDR", &(ch->dma_prd_addr)); + v3_chkpt_load_32(ch_ctx, "DMA_TBL_IDX", &(ch->dma_tbl_index)); + + + for (drive_num = 0; drive_num < 2; drive_num++) { + struct v3_chkpt_ctx * drive_ctx = NULL; + struct ide_drive * drive = &(ch->drives[drive_num]); + + snprintf(buf, 128, "drive-%d-%d", ch_num, drive_num); + drive_ctx = v3_chkpt_open_ctx(ctx->chkpt, ch_ctx, buf); + + v3_chkpt_load_8(drive_ctx, "DRIVE_TYPE", &(drive->drive_type)); + v3_chkpt_load_8(drive_ctx, "SECTOR_COUNT", &(drive->sector_count)); + v3_chkpt_load_8(drive_ctx, "SECTOR_NUM", &(drive->sector_num)); + v3_chkpt_load_16(drive_ctx, "CYLINDER", &(drive->cylinder)); + + v3_chkpt_load_64(drive_ctx, "CURRENT_LBA", &(drive->current_lba)); + v3_chkpt_load_32(drive_ctx, "TRANSFER_LENGTH", &(drive->transfer_length)); + v3_chkpt_load_32(drive_ctx, "TRANSFER_INDEX", &(drive->transfer_index)); + + v3_chkpt_load(drive_ctx, "DATA_BUF", DATA_BUFFER_SIZE, drive->data_buf); + + + /* 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(drive_ctx, "ATAPI_SENSE_DATA", 18, drive->cd_state.sense.buf); + v3_chkpt_load_8(drive_ctx, "ATAPI_CMD", &(drive->cd_state.atapi_cmd)); + v3_chkpt_load(drive_ctx, "ATAPI_ERR_RECOVERY", 12, drive->cd_state.err_recovery.buf); + } else if (drive->drive_type == BLOCK_DISK) { + v3_chkpt_load_32(drive_ctx, "ACCESSED", &(drive->hd_state.accessed)); + v3_chkpt_load_32(drive_ctx, "MULT_SECT_NUM", &(drive->hd_state.mult_sector_num)); + v3_chkpt_load_32(drive_ctx, "CUR_SECT_NUM", &(drive->hd_state.cur_sector_num)); + } + } + } + + return 0; +} + + + +#endif + static struct v3_device_ops dev_ops = { .free = (int (*)(void *))ide_free, +#ifdef V3_CONFIG_CHECKPOINT + .save = ide_save, + .load = ide_load +#endif }; @@ -1540,8 +1679,10 @@ static int connect_fn(struct v3_vm_info * vm, 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; @@ -1707,7 +1848,7 @@ static int ide_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) { 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);