org/jpc/emulator/DriveSet.java

   1 /*
   2     JPC-RR: A x86 PC Hardware Emulator
   3     Release 1
   4
   5     Copyright (C) 2007-2009 Isis Innovation Limited
   6     Copyright (C) 2009 H. Ilari Liusvaara
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License version 2 as published by
  10     the Free Software Foundation.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License along
  18     with this program; if not, write to the Free Software Foundation, Inc.,
  19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21     Based on JPC x86 PC Hardware emulator,
  22     A project from the Physics Dept, The University of Oxford
  23
  24     Details about original JPC can be found at:
  25
  26     www-jpc.physics.ox.ac.uk
  27
  28 */
  29
  30 package org.jpc.emulator;
  31
  32 //Do not even think about adding an import line to this class - especially not import java.net.*!
  33 import java.io.IOException;
  34 import org.jpc.diskimages.BlockDevice;
  35 import org.jpc.diskimages.GenericBlockDevice;
  36
  37 import org.jpc.emulator.AbstractHardwareComponent;
  38
  39 /**
  40  * Represents the set of disk drive devices associated with this emulator
  41  * instance.
  42  * @author Chris Dennis
  43  */
  44 public class DriveSet extends AbstractHardwareComponent
  45 {
  46
  47     public static enum BootType
  48     {
  49         FLOPPY,
  50         HARD_DRIVE,
  51         CDROM;
  52
  53         public static byte toNumeric(BootType type)
  54         {
  55             if(type == FLOPPY)
  56                 return 1;
  57             else if(type == HARD_DRIVE)
  58                 return 2;
  59             else if(type == CDROM)
  60                 return 3;
  61             else
  62                 return 0;
  63         }
  64
  65         public static BootType fromNumeric(byte type)
  66         {
  67             if(type == 1)
  68                 return FLOPPY;
  69             else if(type == 2)
  70                 return HARD_DRIVE;
  71             else if(type == 3)
  72                 return CDROM;
  73             else
  74                 return null;
  75         }
  76     }
  77
  78     private BootType bootType;
  79     private BlockDevice[] ides;
  80
  81     public void dumpStatusPartial(StatusDumper output)
  82     {
  83         super.dumpStatusPartial(output);
  84         output.println("\tbootType " + bootType);
  85
  86         for(int i=0; i < ides.length; i++) {
  87             output.println("\tides[" + i + "] <object #" + output.objectNumber(ides[i]) + ">");
  88             if(ides[i] != null) ides[i].dumpStatus(output);
  89         }
  90     }
  91
  92     public void dumpStatus(StatusDumper output)
  93     {
  94         if(output.dumped(this))
  95             return;
  96
  97         output.println("#" + output.objectNumber(this) + ": DriveSet:");
  98         dumpStatusPartial(output);
  99         output.endObject();
 100     }
 101
 102     public void dumpSRPartial(SRDumper output) throws IOException
 103     {
 104         super.dumpSRPartial(output);
 105         output.dumpByte(BootType.toNumeric(bootType));
 106         output.dumpInt(ides.length);
 107         for(int i = 0; i < ides.length; i++)
 108             output.dumpObject(ides[i]);
 109     }
 110
 111     public DriveSet(SRLoader input) throws IOException
 112     {
 113         super(input);
 114         bootType = BootType.fromNumeric(input.loadByte());
 115         ides = new BlockDevice[input.loadInt()];
 116         for(int i = 0; i < ides.length; i++)
 117             ides[i] = (BlockDevice)input.loadObject();
 118     }
 119
 120     /**
 121      * Constructs a driveset with all parameters specified.
 122      * <p>
 123      * A drive set can be composed of at most four ide devices and two floppy
 124      * drive devices.
 125      * @param boot boot device
 126      * @param hardDriveA primary master hard disk
 127      * @param hardDriveB primary slave hard disk
 128      * @param hardDriveC secondary master hard disk
 129      * @param hardDriveD secondary slave hard disk
 130      */
 131     public DriveSet(BootType boot, BlockDevice hardDriveA, BlockDevice hardDriveB, BlockDevice hardDriveC, BlockDevice hardDriveD)
 132     {
 133         this.bootType = boot;
 134
 135         ides = new BlockDevice[4];
 136         ides[0] = hardDriveA;
 137         ides[1] = hardDriveB;
 138         ides[2] = (hardDriveC == null) ? new GenericBlockDevice(BlockDevice.Type.CDROM) : hardDriveC;
 139         ides[3] = hardDriveD;
 140     }
 141
 142     /**
 143      * Returns the i'th hard drive device.
 144      * <p>
 145      * Devices are numbered from 0 to 3 inclusive in order: primary master,
 146      * primary slave, secondary master, secondary slave.
 147      * @param index drive index
 148      * @return hard drive block device
 149      */
 150     public BlockDevice getHardDrive(int index)
 151     {
 152         return ides[index];
 153     }
 154
 155     public void setHardDrive(int index, BlockDevice device)
 156     {
 157         ides[index] = device;
 158     }
 159
 160     /**
 161      * Returns the boot type being used by this driveset.
 162      * @return boot type
 163      */
 164     public BootType getBootType()
 165     {
 166         return bootType;
 167     }
 168 }