X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fdevices%2Fide.c;h=233470abac2e65b4d271a0899fa52dde89e74061;hb=f01ef51a3da4c56e7e9019714d489cad2fa52d46;hp=d0adb6327ecb4d9163c257f1b5598d2b5940b7e6;hpb=262421e0f445e5427698043eb5b3309f9768a1f2;p=palacios.git

diff --git a/palacios/src/devices/ide.c b/palacios/src/devices/ide.c
index d0adb63..233470a 100644
--- a/palacios/src/devices/ide.c
+++ b/palacios/src/devices/ide.c
@@ -20,7 +20,10 @@
 #include <palacios/vmm.h>
 #include <devices/ide.h>
 #include "ide-types.h"
+#include "atapi-types.h"
 
+#define PRI_DEFAULT_IRQ 14
+#define SEC_DEFAULT_IRQ 15
 
 
 #define PRI_DATA_PORT         0x1f0
@@ -46,11 +49,12 @@
 #define SEC_ADDR_REG_PORT     0x377
 
 
-typedef enum {IDE_DISK, IDE_CDROM, IDE_NONE} ide_dev_type_t;
+#define DATA_BUFFER_SIZE 2048
+
 static const char * ide_dev_type_strs[] = {"HARDDISK", "CDROM", "NONE"};
 
 
-static inline const char * device_type_to_str(ide_dev_type_t type) {
+static inline const char * device_type_to_str(v3_ide_dev_type_t type) {
     if (type > 2) {
 	return NULL;
     }
@@ -60,22 +64,66 @@ static inline const char * device_type_to_str(ide_dev_type_t type) {
 
 
 
+struct ide_cd_state {
+    struct atapi_sense_data sense;
+    uint_t current_lba;
+    uint8_t atapi_cmd;
+    struct atapi_error_recovery err_recovery;
+};
+
+struct ide_hd_state {
 
+};
 
 struct ide_drive {
     // Command Registers
 
-    ide_dev_type_t drive_type;
+    v3_ide_dev_type_t drive_type;
+
+    union {
+	struct v3_ide_cd_ops * cd_ops;
+	struct v3_ide_hd_ops * hd_ops;
+    };
+
+
+    union {
+	struct ide_cd_state cd_state;
+	struct ide_hd_state hd_state;
+    };
+
+    char model[41];
+
+    // Where we are in the data transfer
+    uint_t transfer_index;
+
+    // the length of a transfer
+    // calculated for easy access
+    uint_t transfer_length;
 
 
-    uint8_t sector_count;               // 0x1f2,0x172
+    // We have a local data buffer that we use for IO port accesses
+    uint8_t data_buf[DATA_BUFFER_SIZE];
+
+
+    void * private_data;
+    
+    union {
+	uint8_t sector_count;             // 0x1f2,0x172
+	struct atapi_irq_flags irq_flags;
+    } __attribute__((packed));
+
     uint8_t sector_num;               // 0x1f3,0x173
+
     union {
 	uint16_t cylinder;
+
 	struct {
 	    uint8_t cylinder_low;       // 0x1f4,0x174
 	    uint8_t cylinder_high;      // 0x1f5,0x175
 	} __attribute__((packed));
+
+	// The transfer length requested by the CPU 
+	uint16_t req_len;
     } __attribute__((packed));
 
 
@@ -94,7 +142,9 @@ struct ide_channel {
     struct ide_drive_head_reg drive_head; // 0x1f6,0x176
 
     struct ide_status_reg status;       // [read] 0x1f7,0x177
-    uint8_t command_reg;                // [write] 0x1f7,0x177
+    uint8_t cmd_reg;                // [write] 0x1f7,0x177
+
+    int irq; // this is temporary until we add PCI support
 
     // Control Registers
     struct ide_ctrl_reg ctrl_reg; // [write] 0x3f6,0x376
@@ -108,6 +158,25 @@ struct ide_internal {
 
 
 
+static inline uint16_t be_to_le_16(const uint16_t val) {
+    uint8_t * buf = (uint8_t *)&val;
+    return (buf[0] << 8) | (buf[1]) ;
+}
+
+static inline uint16_t le_to_be_16(const uint16_t val) {
+    return be_to_le_16(val);
+}
+
+
+static inline uint32_t be_to_le_32(const uint32_t val) {
+    uint8_t * buf = (uint8_t *)&val;
+    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+}
+
+static inline uint32_t le_to_be_32(const uint32_t val) {
+    return be_to_le_32(val);
+}
+
 
 static inline int get_channel_index(ushort_t port) {
     if (((port & 0xfff8) == 0x1f0) ||
@@ -136,6 +205,13 @@ static inline int is_lba_enabled(struct ide_channel * channel) {
 }
 
 
+static void ide_raise_irq(struct vm_device * dev, struct ide_channel * channel) {
+    if (channel->ctrl_reg.irq_disable == 0) {
+	v3_raise_irq(dev->vm, channel->irq);
+    }
+}
+
+
 static void drive_reset(struct ide_drive * drive) {
     drive->sector_count = 0x01;
     drive->sector_num = 0x01;
@@ -146,6 +222,10 @@ static void drive_reset(struct ide_drive * drive) {
 	drive->cylinder = 0x0000;
     }
 
+
+    memset(drive->data_buf, 0, sizeof(drive->data_buf));
+    drive->transfer_index = 0;
+
     // Send the reset signal to the connected device callbacks
     //     channel->drives[0].reset();
     //    channel->drives[1].reset();
@@ -160,9 +240,9 @@ static void channel_reset(struct ide_channel * channel) {
     channel->error_reg.val = 0x01;
 
     // clear commands
-    channel->command_reg = 0x00;
+    channel->cmd_reg = 0x00;
 
-    channel->ctrl_reg.irq_enable = 0;
+    channel->ctrl_reg.irq_disable = 0;
 }
 
 static void channel_reset_complete(struct ide_channel * channel) {
@@ -176,24 +256,238 @@ static void channel_reset_complete(struct ide_channel * channel) {
 }
 
 
+static void ide_abort_command(struct vm_device * dev, struct ide_channel * channel) {
+    channel->status.val = 0x41; // Error + ready
+    channel->error_reg.val = 0x04; // No idea...
+
+    ide_raise_irq(dev, channel);
+}
+
+
+// Include the ATAPI interface handlers
+#include "atapi.h"
+
 
 static int write_cmd_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
+    struct ide_internal * ide = (struct ide_internal *)(dev->private_data);
+    struct ide_channel * channel = get_selected_channel(ide, port);
+    struct ide_drive * drive = get_selected_drive(channel);
+
+    if (length != 1) {
+	PrintError("Invalid Write Length on IDE command Port %x\n", port);
+	return -1;
+    }
+
     PrintDebug("IDE: Writing Command Port %x (val=%x)\n", port, *(uint8_t *)src);
-    return -1;
+    
+    channel->cmd_reg = *(uint8_t *)src;
+    
+    switch (channel->cmd_reg) {
+	
+	case 0xa0: // ATAPI Command Packet
+	    if (drive->drive_type != IDE_CDROM) {
+		ide_abort_command(dev, channel);
+	    }
+	    
+	    drive->sector_count = 1;
+
+	    channel->status.busy = 0;
+	    channel->status.write_fault = 0;
+	    channel->status.data_req = 1;
+	    channel->status.error = 0;
+
+	    // reset the data buffer...
+	    drive->transfer_length = ATAPI_PACKET_SIZE;
+	    drive->transfer_index = 0;
+
+	    break;
+	case 0xa1: // ATAPI Identify Device Packet
+	    atapi_identify_device(drive);
+
+	    channel->error_reg.val = 0;
+	    channel->status.val = 0x58; // ready, data_req, seek_complete
+	    
+	    ide_raise_irq(dev, channel);
+	    break;
+	case 0xec: // Identify Device
+	    if (drive->drive_type != IDE_DISK) {
+		drive_reset(drive);
+
+		// JRL: Should we abort here?
+		ide_abort_command(dev, channel);
+	    } else {
+		PrintError("IDE Disks currently not implemented\n");
+		return -1;
+	    }
+	    break;
+	default:
+	    PrintError("Unimplemented IDE command (%x)\n", channel->cmd_reg);
+	    return -1;
+    }
+
+    return length;
 }
 
 
 static int write_data_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
-    PrintDebug("IDE: Writing Data Port %x (val=%x)\n", port, *(uint8_t *)src);
-    return -1;
+    struct ide_internal * ide = (struct ide_internal *)(dev->private_data);
+    struct ide_channel * channel = get_selected_channel(ide, port);
+    struct ide_drive * drive = get_selected_drive(channel);
+
+    //    PrintDebug("IDE: Writing Data Port %x (val=%x, len=%d)\n", 
+    //	       port, *(uint32_t *)src, length);
+    
+    memcpy(drive->data_buf + drive->transfer_index, src, length);    
+    drive->transfer_index += length;
+
+    // Transfer is complete, dispatch the command
+    if (drive->transfer_index >= drive->transfer_length) {
+	switch (channel->cmd_reg) {
+	    case 0x30: // Write Sectors
+		PrintError("Writing Data not yet implemented\n");
+		return -1;
+		
+	    case 0xa0: // ATAPI packet command
+		if (atapi_handle_packet(dev, channel) == -1) {
+		    PrintError("Error handling ATAPI packet\n");
+		    return -1;
+		}
+		break;
+	    default:
+		PrintError("Unhandld IDE Command %x\n", channel->cmd_reg);
+		return -1;
+	}
+    }
+
+    return length;
 }
 
 
-static int read_data_port(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
-    PrintDebug("IDE: Reading Data Port %x\n", port);
+static int read_hd_data(uint8_t * dst, uint_t length, struct vm_device * dev, struct ide_channel * channel) {
+    PrintError("Harddrive data port read not implemented\n");
     return -1;
 }
 
+
+
+static int read_cd_data(uint8_t * dst, uint_t length, struct vm_device * dev, struct ide_channel * channel) {
+    struct ide_drive * drive = get_selected_drive(channel);
+    int data_offset = drive->transfer_index % DATA_BUFFER_SIZE;
+    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);
+    }
+
+    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, 
+		   drive->transfer_index + length);
+	return -1;
+    }
+
+
+
+    if ((data_offset == 0) && (drive->transfer_index > 0)) {
+	
+	if (drive->drive_type == IDE_CDROM) {
+	    if (atapi_update_data_buf(dev, channel) == -1) {
+		PrintError("Could not update CDROM data buffer\n");
+		return -1;
+	    } 
+	} else {
+	    PrintError("IDE Harddrives not implemented\n");
+	    return -1;
+	}
+    }
+
+    memcpy(dst, drive->data_buf + data_offset, length);
+    
+    drive->transfer_index += length;
+
+    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...
+	    
+	    channel->status.data_req = 1;
+
+	    drive->irq_flags.c_d = 0;
+
+	    // Update the request length in the cylinder regs
+	    if (atapi_update_req_len(dev, channel, drive->transfer_length - drive->transfer_index) == -1) {
+		PrintError("Could not update request length after completed increment\n");
+		return -1;
+	    }
+	} else {
+	    // This was the final read of the request
+	    channel->status.data_req = 0;
+	    channel->status.ready = 1;
+	    
+	    drive->irq_flags.c_d = 1;
+	    drive->irq_flags.rel = 0;
+	}
+
+	drive->irq_flags.io_dir = 1;
+	channel->status.busy = 0;
+
+	ide_raise_irq(dev, channel);
+    }
+
+    return length;
+}
+
+
+static int read_drive_id(uint8_t * dst, uint_t length, struct vm_device * dev, struct ide_channel * channel) {
+    struct ide_drive * drive = get_selected_drive(channel);
+
+    channel->status.busy = 0;
+    channel->status.ready = 1;
+    channel->status.write_fault = 0;
+    channel->status.seek_complete = 1;
+    channel->status.corrected = 0;
+    channel->status.error = 0;
+		
+    
+    memcpy(dst, drive->data_buf + drive->transfer_index, length);
+    drive->transfer_index += length;
+    
+    if (drive->transfer_index >= drive->transfer_length) {
+	channel->status.data_req = 0;
+    }
+    
+    return length;
+}
+
+
+static int ide_read_data_port(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
+    struct ide_internal * ide = (struct ide_internal *)(dev->private_data);
+    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);
+
+    if ((channel->cmd_reg == 0xec) ||
+	(channel->cmd_reg == 0xa1)) {
+	return read_drive_id((uint8_t *)dst, length, dev, channel);
+    }
+
+    if (drive->drive_type == IDE_CDROM) {
+	if (read_cd_data((uint8_t *)dst, length, dev, channel) == -1) {
+	    PrintError("IDE: Could not read CD Data\n");
+	    return -1;
+	}
+    } else if (drive->drive_type == IDE_DISK) {
+	if (read_hd_data((uint8_t *)dst, length, dev, channel) == -1) {
+	    PrintError("IDE: Could not read HD Data\n");
+	    return -1;
+	}
+    } else {
+	memset((uint8_t *)dst, 0, length);
+    }
+
+    return length;
+}
+
 static int write_port_std(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
     struct ide_internal * ide = (struct ide_internal *)(dev->private_data);
     struct ide_channel * channel = get_selected_channel(ide, port);
@@ -354,6 +648,8 @@ static int read_port_std(ushort_t port, void * dst, uint_t length, struct vm_dev
 	    return -1;
     }
 
+    PrintDebug("\tVal=%x\n", *(uint8_t *)dst);
+
     return length;
 }
 
@@ -365,9 +661,16 @@ static void init_drive(struct ide_drive * drive) {
     drive->sector_num = 0x01;
     drive->cylinder = 0x0000;
 
-
     drive->drive_type = IDE_NONE;
 
+    memset(drive->model, 0, sizeof(drive->model));
+
+    drive->transfer_index = 0;
+    drive->transfer_length = 0;
+    memset(drive->data_buf, 0, sizeof(drive->data_buf));
+
+    drive->private_data = NULL;
+    drive->cd_ops = NULL;
 }
 
 static void init_channel(struct ide_channel * channel) {
@@ -376,9 +679,10 @@ static void init_channel(struct ide_channel * channel) {
     channel->error_reg.val = 0x01;
     channel->drive_head.val = 0x00;
     channel->status.val = 0x00;
-    channel->command_reg = 0x00;
+    channel->cmd_reg = 0x00;
     channel->ctrl_reg.val = 0x08;
 
+
     for (i = 0; i < 2; i++) {
 	init_drive(&(channel->drives[i]));
     }
@@ -390,6 +694,9 @@ static void init_ide_state(struct ide_internal * ide) {
 
     for (i = 0; i < 2; i++) {
 	init_channel(&(ide->channels[i]));
+
+	// JRL: this is a terrible hack...
+	ide->channels[i].irq = PRI_DEFAULT_IRQ + i;
     }
 }
 
@@ -407,7 +714,7 @@ static int init_ide(struct vm_device * dev) {
 		   &read_port_std, &write_port_std);
 
     v3_dev_hook_io(dev, PRI_DATA_PORT, 
-		   &read_data_port, &write_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, 
@@ -428,7 +735,7 @@ static int init_ide(struct vm_device * dev) {
 		   &read_port_std, &write_port_std);
 
     v3_dev_hook_io(dev, SEC_DATA_PORT, 
-		   &read_data_port, &write_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, 
@@ -482,3 +789,79 @@ struct vm_device *  v3_create_ide() {
 
     return device;
 }
+
+
+
+
+
+int v3_ide_register_cdrom(struct vm_device * ide_dev, 
+			  uint_t bus_num, 
+			  uint_t drive_num,
+			  char * dev_name, 
+			  struct v3_ide_cd_ops * ops, 
+			  void * private_data) {
+
+    struct ide_internal * ide  = (struct ide_internal *)(ide_dev->private_data);  
+    struct ide_channel * channel = NULL;
+    struct ide_drive * drive = NULL;
+
+    V3_ASSERT((bus_num >= 0) && (bus_num < 2));
+    V3_ASSERT((drive_num >= 0) && (drive_num < 2));
+
+    channel = &(ide->channels[bus_num]);
+    drive = &(channel->drives[drive_num]);
+    
+    if (drive->drive_type != IDE_NONE) {
+	PrintError("Device slot (bus=%d, drive=%d) already occupied\n", bus_num, drive_num);
+	return -1;
+    }
+
+    strncpy(drive->model, dev_name, sizeof(drive->model) - 1);
+
+    while (strlen((char *)(drive->model)) < 40) {
+	strcat((char*)(drive->model), " ");
+    }
+
+
+    drive->drive_type = IDE_CDROM;
+
+    drive->cd_ops = ops;
+
+    drive->private_data = private_data;
+
+    return 0;
+}
+
+
+int v3_ide_register_harddisk(struct vm_device * ide_dev, 
+			     uint_t bus_num, 
+			     uint_t drive_num, 
+			     char * dev_name, 
+			     struct v3_ide_hd_ops * ops, 
+			     void * private_data) {
+
+    struct ide_internal * ide  = (struct ide_internal *)(ide_dev->private_data);  
+    struct ide_channel * channel = NULL;
+    struct ide_drive * drive = NULL;
+
+    V3_ASSERT((bus_num >= 0) && (bus_num < 2));
+    V3_ASSERT((drive_num >= 0) && (drive_num < 2));
+
+    channel = &(ide->channels[bus_num]);
+    drive = &(channel->drives[drive_num]);
+    
+    if (drive->drive_type != IDE_NONE) {
+	PrintError("Device slot (bus=%d, drive=%d) already occupied\n", bus_num, drive_num);
+	return -1;
+    }
+
+    strncpy(drive->model, dev_name, sizeof(drive->model) - 1);
+
+    drive->drive_type = IDE_DISK;
+
+    drive->hd_ops = ops;
+
+    drive->private_data = private_data;
+
+    return 0;
+}