org/jpc/diskimages/GenericBlockDevice.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.diskimages;
  31
  32 import java.io.*;
  33 import org.jpc.emulator.SRLoader;
  34 import org.jpc.emulator.SRDumper;
  35 import org.jpc.emulator.StatusDumper;
  36 import org.jpc.emulator.SRDumpable;
  37
  38
  39 public class GenericBlockDevice implements BlockDevice, SRDumpable
  40 {
  41     private DiskImage image;
  42     private boolean isLocked;
  43     private BlockDevice.Type diskType;
  44
  45     public void dumpStatusPartial(StatusDumper output)
  46     {
  47         output.println("\tdiskType " + diskType + " isLocked " + isLocked);
  48         output.println("\timage <object #" + output.objectNumber(image) + ">"); if(image != null) image.dumpStatus(output);
  49     }
  50
  51     public void dumpStatus(StatusDumper output)
  52     {
  53         if(output.dumped(this))
  54             return;
  55
  56         output.println("#" + output.objectNumber(this) + ": GenericBlockDevice:");
  57         dumpStatusPartial(output);
  58         output.endObject();
  59     }
  60
  61     public void dumpSRPartial(SRDumper output) throws IOException
  62     {
  63         output.dumpObject(image);
  64         output.dumpBoolean(isLocked);
  65         switch(diskType) {
  66         case FLOPPY:
  67             output.dumpByte((byte)0);
  68             break;
  69         case HARDDRIVE:
  70             output.dumpByte((byte)1);
  71             break;
  72         case CDROM:
  73             output.dumpByte((byte)2);
  74             break;
  75         }
  76     }
  77
  78     public GenericBlockDevice(SRLoader input) throws IOException
  79     {
  80         input.objectCreated(this);
  81         image = (DiskImage)(input.loadObject());
  82         isLocked = input.loadBoolean();
  83         byte tmpDiskType = input.loadByte();
  84         switch(tmpDiskType) {
  85         case 0:
  86             diskType = BlockDevice.Type.FLOPPY;
  87             break;
  88         case 1:
  89             diskType = BlockDevice.Type.HARDDRIVE;
  90             break;
  91         case 2:
  92             diskType = BlockDevice.Type.CDROM;
  93             break;
  94         case 3:
  95             throw new IOException("Invalid disk type in GenericBlockDevice.");
  96         }
  97     }
  98
  99     public GenericBlockDevice(BlockDevice.Type driveType)
 100     {
 101         diskType = driveType;
 102         isLocked = false;
 103         image = null;
 104     }
 105
 106     public GenericBlockDevice(DiskImage _image) throws IOException
 107     {
 108         diskType = _image.getType();
 109         isLocked = false;
 110         image = _image;
 111         image.use();
 112     }
 113
 114     public GenericBlockDevice(DiskImage _image, BlockDevice.Type expectedType) throws IOException
 115     {
 116         if(_image != null && _image.getType() != expectedType)
 117             throw new IOException("Disk is of wrong type.");
 118         diskType = expectedType;
 119         isLocked = false;
 120         image = _image;
 121         if(image != null)
 122             image.use();
 123     }
 124
 125     public byte[] getImageID()
 126     {
 127         if(image != null)
 128             return image.getImageID();
 129         else
 130             return null;
 131     }
 132
 133     public void close()
 134     {
 135         image.unuse();
 136         image = null;
 137     }
 138
 139     public int read(long sectorNumber, byte[] buffer, int size)
 140     {
 141         if(image != null)
 142             return image.read(sectorNumber, buffer, size);
 143         else
 144             return -1;
 145     }
 146
 147     public int write(long sectorNumber, byte[] buffer, int size)
 148     {
 149         if(image != null)
 150             return image.write(sectorNumber, buffer, size);
 151         else
 152             return -1;
 153     }
 154
 155     public boolean isInserted()
 156     {
 157         return (image != null);
 158     }
 159
 160     public boolean isLocked()
 161     {
 162         return isLocked;
 163     }
 164
 165     public boolean isReadOnly()
 166     {
 167         if(image != null)
 168             return image.isReadOnly();
 169         else
 170             return false;
 171     }
 172
 173     public void setLock(boolean locked)
 174     {
 175         isLocked = locked;
 176     }
 177
 178     public long getTotalSectors()
 179     {
 180         if(image != null)
 181             return image.getTotalSectors();
 182         else
 183             return 0;
 184     }
 185
 186     public int getCylinders()
 187     {
 188         if(image != null)
 189             return image.getCylinders();
 190         else
 191             return 0;
 192     }
 193
 194     public int getHeads()
 195     {
 196         if(image != null)
 197             return image.getHeads();
 198         else
 199             return 0;
 200     }
 201
 202     public int getSectors()
 203     {
 204         if(image != null)
 205             return image.getSectors();
 206         else
 207             return 0;
 208     }
 209
 210     public BlockDevice.Type getType()
 211     {
 212         return diskType;
 213     }
 214
 215     public String getImageFileName()
 216     {
 217         if(image != null)
 218            return image.getImageFileName();
 219         else
 220            return null;
 221     }
 222
 223     public void configure(String spec) throws IOException
 224     {
 225         //Just implement this, as its required by interface.
 226         DiskImage dImage = new DiskImage(spec, false);
 227         configure(dImage);
 228     }
 229
 230     public void configure(DiskImage spec) throws IOException
 231     {
 232         if(spec != null && spec.getType() != diskType)
 233             throw new IOException("Trying to put disk of wrong type to drive.");
 234         if(isLocked)
 235             throw new IOException("Can not change disk in locked drive.");
 236         if(image != null)
 237             image.unuse();
 238         image = spec;
 239         if(image != null)
 240             image.use();
 241     }
 242
 243     public DiskImage getImage()
 244     {
 245         return image;
 246     }
 247
 248 }