mirror of
https://github.com/badvision/jace.git
synced 2024-06-09 15:29:34 +00:00
229 lines
8.4 KiB
Java
229 lines
8.4 KiB
Java
/*
|
|
* Copyright (C) 2012 Brendan Robert (BLuRry) brendan.robert@gmail.com.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301 USA
|
|
*/
|
|
package jace.hardware.massStorage;
|
|
|
|
import jace.Emulator;
|
|
import jace.EmulatorUILogic;
|
|
import jace.apple2e.MOS65C02;
|
|
import jace.core.Computer;
|
|
import jace.core.RAM;
|
|
import static jace.hardware.ProdosDriver.*;
|
|
import jace.hardware.ProdosDriver.MLI_COMMAND_TYPE;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.Arrays;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
/**
|
|
* Representation of a Prodos Volume which maps to a physical folder on the
|
|
* actual hard drive. This is used by CardMassStorage in the event the disk path
|
|
* is a folder and not a disk image. FreespaceBitmap and the various Node
|
|
* classes are used to represent the filesystem structure.
|
|
*
|
|
* @author Brendan Robert (BLuRry) brendan.robert@gmail.com
|
|
*/
|
|
public class ProdosVirtualDisk implements IDisk {
|
|
|
|
public static final int VOLUME_START = 2;
|
|
public static final int FREESPACE_BITMAP_START = 6;
|
|
byte[] ioBuffer;
|
|
File physicalRoot;
|
|
private final DiskNode[] physicalMap;
|
|
DirectoryNode rootDirectory;
|
|
FreespaceBitmap freespaceBitmap;
|
|
|
|
public ProdosVirtualDisk(File rootPath) throws IOException {
|
|
ioBuffer = new byte[BLOCK_SIZE];
|
|
physicalMap = new DiskNode[MAX_BLOCK];
|
|
initDiskStructure();
|
|
setPhysicalPath(rootPath);
|
|
}
|
|
|
|
@Override
|
|
public void mliRead(int block, int bufferAddress, RAM memory) throws IOException {
|
|
// System.out.println("Read block " + block + " to " + Integer.toHexString(bufferAddress));
|
|
DiskNode node = physicalMap[block];
|
|
Arrays.fill(ioBuffer, (byte) 0);
|
|
if (node == null) {
|
|
System.out.println("Unknown block " + Integer.toHexString(block));
|
|
} else {
|
|
node.readBlock(ioBuffer);
|
|
}
|
|
for (int i = 0; i < ioBuffer.length; i++) {
|
|
memory.write(bufferAddress + i, ioBuffer[i], false, false);
|
|
}
|
|
// System.out.println("Block " + Integer.toHexString(block));
|
|
// for (int i = 0; i < 32; i++) {
|
|
// String hex = "";
|
|
// String text = "";
|
|
// for (int j = 0; j < 16; j++) {
|
|
// int val = 0x0ff & memory.readRaw(bufferAddress + i * 16 + j);
|
|
// char show = (char) (((val & 0x7f) < ' ') ? '.' : val & 0x7f);
|
|
// hex += (val < 16 ? "0" : "") + Integer.toString(val, 16) + " ";
|
|
// text += show;
|
|
// }
|
|
// System.out.println(hex + " " + text);
|
|
// }
|
|
}
|
|
|
|
@Override
|
|
public void mliWrite(int block, int bufferAddress, RAM memory) throws IOException {
|
|
System.out.println("Write block " + block + " to " + Integer.toHexString(bufferAddress));
|
|
throw new IOException("Write not implemented yet!");
|
|
// DiskNode node = physicalMap.get(block);
|
|
// RAM memory = computer.getMemory();
|
|
// if (node == null) {
|
|
// // CAPTURE WRITES TO UNUSED BLOCKS
|
|
// } else {
|
|
// node.readBlock(block, ioBuffer);
|
|
// for (int i=0; i < BLOCK_SIZE; i++) {
|
|
// memory.write(bufferAddress+i, ioBuffer[i], false);
|
|
// }
|
|
// }
|
|
}
|
|
|
|
@Override
|
|
public void mliFormat() {
|
|
throw new UnsupportedOperationException("Formatting for this type of media is not supported!");
|
|
}
|
|
|
|
public File locateFile(File rootPath, String string) {
|
|
File mostLikelyMatch = null;
|
|
for (File f : rootPath.listFiles()) {
|
|
if (f.getName().equalsIgnoreCase(string)) {
|
|
return f;
|
|
}
|
|
// This is not sufficient, a more deterministic approach should be taken
|
|
if (string.toUpperCase().startsWith(f.getName().toUpperCase())) {
|
|
if (mostLikelyMatch == null || f.getName().length() > mostLikelyMatch.getName().length()) {
|
|
mostLikelyMatch = f;
|
|
}
|
|
}
|
|
}
|
|
return mostLikelyMatch;
|
|
}
|
|
|
|
public int getNextFreeBlock(int start) throws IOException {
|
|
// Don't allocate Zero block for anything!
|
|
// for (int i = 0; i < MAX_BLOCK; i++) {
|
|
for (int i = start; i < MAX_BLOCK; i++) {
|
|
if (physicalMap[i] == null) {
|
|
return i;
|
|
}
|
|
}
|
|
throw new IOException("Virtual Disk Full!");
|
|
}
|
|
|
|
public int allocateEntry(DiskNode node) throws IOException {
|
|
return allocateEntryNear(node, FREESPACE_BITMAP_START);
|
|
}
|
|
|
|
public int allocateEntryNear(DiskNode node, int start) throws IOException {
|
|
if (isNodeAllocated(node)) {
|
|
return node.getBaseBlock();
|
|
}
|
|
int block = getNextFreeBlock(start);
|
|
node.setBaseBlock(block);
|
|
physicalMap[block] = node;
|
|
return block;
|
|
}
|
|
|
|
public boolean isNodeAllocated(DiskNode node) {
|
|
return node.getBaseBlock() >= 0 && physicalMap[node.getBaseBlock()] == node;
|
|
}
|
|
|
|
// Mark space occupied by nodes as free (remove allocation mapping)
|
|
public void deallocateEntry(DiskNode node) {
|
|
// Only de-map nodes if the allocation table is actually pointing to the nodes!
|
|
if (physicalMap[node.getBaseBlock()] != null && physicalMap[node.getBaseBlock()].equals(node)) {
|
|
physicalMap[node.getBaseBlock()] = null;
|
|
}
|
|
node.additionalNodes.stream().filter((sub)
|
|
-> (physicalMap[sub.getBaseBlock()] != null && physicalMap[sub.getBaseBlock()].equals(sub))).
|
|
forEach((sub) -> {
|
|
physicalMap[sub.getBaseBlock()] = null;
|
|
});
|
|
}
|
|
|
|
// Is the specified block in use?
|
|
public boolean isBlockAllocated(int i) {
|
|
return (i >= physicalMap.length || physicalMap[i] != null);
|
|
}
|
|
|
|
@Override
|
|
public void boot0(int slot, Computer computer) throws IOException {
|
|
File prodos = locateFile(physicalRoot, "PRODOS.SYS");
|
|
if (prodos == null || !prodos.exists()) {
|
|
throw new IOException("Unable to locate PRODOS.SYS");
|
|
}
|
|
computer.getCpu().suspend();
|
|
byte slot16 = (byte) (slot << 4);
|
|
((MOS65C02) computer.getCpu()).X = slot16;
|
|
RAM memory = computer.getMemory();
|
|
memory.write(CardMassStorage.SLT16, slot16, false, false);
|
|
memory.write(MLI_COMMAND, (byte) MLI_COMMAND_TYPE.READ.intValue, false, false);
|
|
memory.write(MLI_UNITNUMBER, slot16, false, false);
|
|
// Write location to block read routine to zero page
|
|
memory.writeWord(0x048, 0x0c000 + CardMassStorage.DEVICE_DRIVER_OFFSET + (slot * 0x0100), false, false);
|
|
EmulatorUILogic.brun(prodos, 0x02000);
|
|
computer.getCpu().resume();
|
|
}
|
|
|
|
public File getPhysicalPath() {
|
|
return physicalRoot;
|
|
}
|
|
|
|
private void initDiskStructure() throws IOException {
|
|
freespaceBitmap = new FreespaceBitmap(this, FREESPACE_BITMAP_START);
|
|
}
|
|
|
|
private void setPhysicalPath(File f) throws IOException {
|
|
if (physicalRoot != null && physicalRoot.equals(f)) {
|
|
return;
|
|
}
|
|
physicalRoot = f;
|
|
if (!physicalRoot.exists() || !physicalRoot.isDirectory()) {
|
|
try {
|
|
throw new IOException("Root path must be a directory that exists!");
|
|
} catch (IOException ex) {
|
|
Logger.getLogger(ProdosVirtualDisk.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
// Root directory ALWAYS starts on block 2!
|
|
rootDirectory = new DirectoryNode(this, physicalRoot, VOLUME_START, true);
|
|
rootDirectory.setName("VIRTUAL");
|
|
}
|
|
|
|
@Override
|
|
public void eject() {
|
|
// Nothing to do here...
|
|
}
|
|
|
|
@Override
|
|
public boolean isWriteProtected() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int getSize() {
|
|
return MAX_BLOCK;
|
|
}
|
|
}
|