2021-05-24 21:40:18 -04:00

370 lines
12 KiB
Executable File

# Simple tool to manipulate MicroDrive/Turbo CF Disk Images
# Bobbi 2021
import getopt
import os
import sys
# Sensible defaults for 512MB CF Card
default_cyls = 1006
default_heads = 16
default_sectors = 63
default_gsvers = 0 # Apple //e
parttab = dict()
parttab['cyls'] = -1
parttab['heads'] = -1
parttab['sectors'] = -1
parttab['gsvers'] = -1
parttab['numparts1'] = 0
parttab['numparts2'] = 0
parttab['start1'] = list()
parttab['len1'] = list()
parttab['start2'] = list()
parttab['len2'] = list()
blocksz = 512
# This is 6502 code that must be present in the disk image from offset 0x0200 to 0x03ff
code_200 = [
0x8e, 0x00, 0x82, 0x86, 0x43, 0x8a, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x01, 0x8d, 0x81,
0x80, 0xa0, 0x00, 0x84, 0x00, 0x84, 0x02, 0xa0, 0xff, 0xb1, 0x00, 0x8d, 0x80, 0x80, 0xa0, 0xf2,
0xb1, 0x00, 0xc9, 0xc9, 0xd0, 0x38, 0xc8, 0xb1, 0x00, 0xc9, 0xc4, 0xd0, 0x31, 0xc8, 0xb1, 0x00,
0xc9, 0xc5, 0xf0, 0x16, 0xc9, 0xc4, 0xf0, 0x0e, 0x85, 0x02, 0xc9, 0xd2, 0xf0, 0x0c, 0xc9, 0xd5,
0xf0, 0x04, 0xc9, 0xd4, 0xd0, 0x18, 0xa9, 0x02, 0xd0, 0x02, 0xa9, 0x00, 0x8d, 0x02, 0x82, 0xa0,
0xf9, 0xb1, 0x00, 0xc9, 0xca, 0xd0, 0x07, 0xc8, 0xb1, 0x00, 0xc9, 0xcc, 0xf0, 0x0a, 0x20, 0x58,
0xfc, 0x20, 0x39, 0xfb, 0xa0, 0x08, 0xd0, 0x2e, 0x20, 0x5c, 0x81, 0xa0, 0x00, 0x84, 0x46, 0x84,
0x47, 0x84, 0x44, 0xc8, 0x84, 0x42, 0xa9, 0x08, 0x85, 0x45, 0xad, 0x00, 0x82, 0x85, 0x43, 0x20,
0xff, 0xff, 0xb0, 0x0d, 0xad, 0x00, 0x08, 0xc9, 0x01, 0xd0, 0x06, 0xae, 0x00, 0x82, 0x4c, 0x01,
0x08, 0x20, 0x58, 0xfc, 0xa0, 0x06, 0x20, 0x36, 0x81, 0x4c, 0x00, 0xe0, 0xa8, 0x80, 0xc1, 0x80,
0xd8, 0x80, 0xf1, 0x80, 0x08, 0x81, 0x1d, 0x81, 0xb0, 0x04, 0xad, 0xad, 0xa0, 0xd2, 0xc1, 0xcd,
0xc6, 0xe1, 0xf3, 0xf4, 0xa0, 0xc9, 0xc4, 0xc5, 0xa0, 0xc3, 0xe1, 0xf2, 0xe4, 0xa0, 0xad, 0xad,
0x00, 0xb1, 0x04, 0xad, 0xad, 0xa0, 0xd4, 0xf5, 0xf2, 0xe2, 0xef, 0xa0, 0xc9, 0xc4, 0xc5, 0xa0,
0xc3, 0xe1, 0xf2, 0xe4, 0xa0, 0xad, 0xad, 0x00, 0xb0, 0x05, 0xa8, 0xe3, 0xa9, 0xa0, 0xb1, 0xb9,
0xb9, 0xb6, 0xa0, 0xca, 0xef, 0xe1, 0xe3, 0xe8, 0xe9, 0xed, 0xa0, 0xcc, 0xe1, 0xee, 0xe7, 0xe5,
0x00, 0xb1, 0x05, 0xd6, 0xef, 0xec, 0xf5, 0xed, 0xe5, 0xa0, 0xee, 0xef, 0xf4, 0xa0, 0xe6, 0xef,
0xf2, 0xed, 0xe1, 0xf4, 0xf4, 0xe5, 0xe4, 0x00, 0xd0, 0x06, 0xc9, 0xc4, 0xc5, 0xa0, 0xc3, 0xe1,
0xf2, 0xe4, 0xa0, 0xee, 0xef, 0xf4, 0xa0, 0xe6, 0xef, 0xf5, 0xee, 0xe4, 0x00, 0xd8, 0x07, 0xd6,
0xef, 0xec, 0xf5, 0xed, 0xe5, 0xf3, 0xa0, 0xb1, 0xae, 0xae, 0xa0, 0xa0, 0xe1, 0xf6, 0xe1, 0xe9,
0xec, 0xe1, 0xe2, 0xec, 0xe5, 0x00, 0xb9, 0x9c, 0x80, 0x85, 0x00, 0xb9, 0x9d, 0x80, 0x85, 0x01,
0xa0, 0x00, 0xb1, 0x00, 0x8d, 0x55, 0x81, 0xc8, 0xb1, 0x00, 0x8d, 0x56, 0x81, 0xc8, 0xa2, 0x00,
0xb1, 0x00, 0xf0, 0x07, 0x9d, 0xff, 0xff, 0xc8, 0xe8, 0xd0, 0xf5, 0x60, 0xac, 0x02, 0x82, 0x20,
0x36, 0x81, 0xa0, 0x04, 0x20, 0x36, 0x81, 0xa5, 0x02, 0xf0, 0xf0, 0xac, 0x1a, 0xc8, 0xc0, 0x02,
0x90, 0x11, 0xa5, 0x02, 0xf0, 0x0d, 0xb9, 0xec, 0x81, 0x48, 0xa0, 0x0a, 0x20, 0x36, 0x81, 0x68,
0x8d, 0xe3, 0x07, 0xad, 0x61, 0xc0, 0x0d, 0x62, 0xc0, 0x10, 0xd0, 0xa5, 0x02, 0xf0, 0xf4, 0xad,
0x00, 0xc0, 0x10, 0xef, 0xc9, 0xba, 0x90, 0x02, 0x29, 0xdf, 0xac, 0x10, 0xc0, 0xac, 0x1a, 0xc8,
0xd9, 0xec, 0x81, 0xf0, 0x05, 0x88, 0xd0, 0xf8, 0xf0, 0xd9, 0x88, 0xf0, 0xae, 0x98, 0x0a, 0x0a,
0xa8, 0x8c, 0x01, 0x82, 0xa2, 0x00, 0xb9, 0x80, 0xc8, 0x48, 0xbd, 0x80, 0xc8, 0x85, 0x1e, 0x68,
0x9d, 0x80, 0xc8, 0xa5, 0x1e, 0x99, 0x80, 0xc8, 0xc8, 0xe8, 0xe0, 0x04, 0x90, 0xe8, 0xac, 0x01,
0x82, 0xa2, 0x00, 0xb9, 0x40, 0xc8, 0x48, 0xbd, 0x40, 0xc8, 0x85, 0x1e, 0x68, 0x9d, 0x40, 0xc8,
0xa5, 0x1e, 0x99, 0x40, 0xc8, 0xc8, 0xe8, 0xe0, 0x04, 0x90, 0xe8, 0x60, 0xb0, 0xb1, 0xb2, 0xb3,
0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0x00, 0x00, 0x00
# Write val as a 16 bit integer into array data[], starting at index start
def write16(data, start, val):
data[start] = val & 0x00ff
data[start + 1] = (val & 0xff00) >> 8
# Read a 32 bit integer from array data[], starting at index start
def read32(data, start):
return (data[start] + 256 * (data[start+ 1]
+ (256 * data[start+ 2] + (256 * data[start+ 3]))))
# Write val as a 32 bit integer into array data[], starting at index start
def write32(data, start, val):
data[start] = val & 0x000000ff
data[start + 1] = (val & 0x0000ff00) >> 8
data[start + 2] = (val & 0x00ff0000) >> 16
data[start + 3] = (val & 0xff000000) >> 24
# Parse partition table from file f and populate parttab
def read_part_tbl(f):
with open(f, 'rb') as infile:
b =
parttab['cyls'] = b[0x02] + b[0x03] * 256
parttab['heads'] = b[0x06] + b[0x07] * 256
parttab['sectors'] = b[0x08] + b[0x09] * 256
parttab['numparts1'] = b[0x0c]
parttab['numparts2'] = b[0x0d]
parttab['gsvers'] = b[0x18] + b[0x19] * 256
parttab['start1'] = list()
parttab['len1'] = list()
parttab['start2'] = list()
parttab['len2'] = list()
if parttab['numparts1'] > 0:
idx = 0x20
for i in range(parttab['numparts1']):
parttab['start1'].append(read32(b, idx + i * 4))
parttab['len1'].append(read32(b, idx + 0x20 + i * 4))
if parttab['numparts2'] > 0:
idx = 0x80
for i in range(parttab['numparts2']):
parttab['start2'].append(read32(b, idx + i * 4))
parttab['len2'].append(read32(b, idx + 0x20 + i * 4))
# Display partition table information in parttab
def print_part_tbl():
if parttab['gsvers'] == 0:
dma = 'iie'
elif parttab['gsvers'] == 1:
dma = 'gsrom01'
elif parttab['gsvers'] == 2:
dma = 'undefined'
elif parttab['gsvers'] == 3:
dma = 'gsrom03'
elif parttab['gsvers'] == 4:
dma = 'off'
dma = '?'
print('\nMicroDrive/Turbo Partition Table\n')
print(' Cylinders: {}'.format(parttab['cyls']))
print(' Heads: {}'.format(parttab['heads']))
print(' Sectors: {}'.format(parttab['sectors']))
print(' DMA Mode: {}'.format(dma))
if parttab['numparts1'] > 0:
print('\n # Start End Length')
for i in range(parttab['numparts1']):
st = parttab['start1'][i]
ln = parttab['len1'][i]
print(' {0} {1:8d} {2:8d} {3:8d}'
.format(i + 1, st, st + ln - 1, ln))
if parttab['numparts2'] > 0:
for i in range(parttab['numparts2']):
st = parttab['start2'][i]
ln = parttab['len2'][i]
print(' {0} {1:8d} {2:8d} {3:8d}'
.format(i + 9, st, st + ln - 1, ln))
# Write partition table in parttab to file f
# Writes 256 blocks (ie 128K)
def write_part_tbl(f):
magic = 0xccca
if ((parttab['cyls'] == -1)
or (parttab['heads'] == -1)
or (parttab['sectors'] == -1)
or (parttab['gsvers'] == -1)
or (parttab['numparts1'] == -1)
or (parttab['numparts2'] == -1)):
print('** Not writing partition table - uninitialized data **')
b = [0] * blocksz
write16(b, 0x00, magic)
write16(b, 0x02, parttab['cyls'])
write16(b, 0x06, parttab['heads'])
write16(b, 0x08, parttab['sectors'])
b[0x0c] = parttab['numparts1']
b[0x0d] = parttab['numparts2']
write16(b, 0x18, parttab['gsvers'])
for i in range(parttab['numparts1']):
write32(b, 0x20 + i * 4, parttab['start1'][i])
write32(b, 0x40 + i * 4, parttab['len1'][i])
for i in range(parttab['numparts2']):
write32(b, 0x80 + i * 4, parttab['start2'][i])
write32(b, 0xa0 + i * 4, parttab['len2'][i])
with open(f, 'wb') as outfile:
block = bytes(b)
block = bytes(code_200)
block = bytes([0] * blocksz)
for i in range(254):
# Obtain volume name of a partition
def get_volname(infile, startidx): * blocksz + 1024)
mdb =
if (mdb[0] == 0x42) and (mdb[1] == 0x44): # HFS Signature in Block 2
fstype = 'HFS' * blocksz + 1024 + 36)
volbytes =
volname = bytearray()
for i in range(0, volbytes[0] & 0x0f):
volname.append(volbytes[i + 1])
fstype = 'ProDOS' # If not HFS, must be ProDOS * blocksz + 1024 + 4)
volbytes =
volname = bytearray()
for i in range(0, volbytes[0] & 0x0f):
volname.append(volbytes[i + 1])
return (fstype, volname.decode('ascii'))
# Extract partition n from file f and write it to file named
# according to the volume name
def extract_partition(f, n):
if n < 8:
st = parttab['start1'][n]
ln = parttab['len1'][n]
st = parttab['start2'][n - 8]
ln = parttab['len2'][n - 8]
with open(f, 'rb') as infile:
(fstype, volname) = get_volname(infile, st)
print('** Partition ' + str(n + 1) + ' ' + fstype + ' Volume \'' + volname + '\'')
if fstype == 'HFS':
outputfile = volname + '.hfs'
elif fstype == 'ProDOS':
outputfile = volname + '.po' * blocksz)
d = * blocksz)
print('Writing {} bytes to {}'.format(len(d), outputfile))
with open(outputfile, 'wb') as outfile:
# Extract all partitions from file f
def explode_mdt_image(f):
for i in range(parttab['numparts1']):
extract_partition(f, i)
for i in range(parttab['numparts2']):
extract_partition(f, i + 8)
# Build an MDT image file f from a list of .po files and update the
# partition table to match the files
def assemble_mdt_image(f, files):
# Add a partition to parttab. i is the zero-based index
def add_partition(i, start, length):
if i < 8:
parttab['numparts1'] += 1
parttab['numparts2'] += 1
currblk = 256
numparts = 0
for filename in files:
status = os.stat(filename)
sz = status.st_size // 512
add_partition(numparts, currblk, sz)
numparts += 1
currblk += sz
for filename in files:
with open(filename, 'rb') as infile:
print(' Reading {} ...'.format(filename))
d =
with open(f, 'ab') as outfile:
print('New CF card image created in {}'.format(f))
def initialize_blank_mdt():
def usage():
print(' mdttool [-haxl] [-C nnnn] [-H nn] [-S nn] [-D mode] [-o outputfile] inputfile [inputfile2...]\n')
print(' -h Show this help')
print(' -a Assemble CF Card image from list of .PO disk images')
print(' -x eXplode a CF Card image into constituent partitions')
print(' -l Display partition table');
print(' -C nnnn Set number of cylinders (when assembling new image)')
print(' -H nn Set number of heads (when assembling new image)')
print(' -S nn Set number of sectors (when assembling new image)')
print(' -D mode DMA mode (when assembling new image)')
print(' mode can be off, iie, gsrom01, gsrom03')
# Main entry point and argument handling
def main():
opts, args = getopt.getopt(
['help', 'output=', 'assemble', 'explode', 'list',
'cylinders', 'heads', 'sectors', 'dma'])
except getopt.GetoptError as err:
infile = None
outfile = None
assemble = False
explode = False
printtab = False
cylinders = default_cyls
heads = default_heads
sectors = default_sectors
gsvers = default_gsvers
for o, a in opts:
if o in ('-h', '--help'):
elif o in ('-o', '--output'):
outfile = a
elif o in ('-a', '--assemble'):
assemble = True
elif o in ('-x', '--explode'):
explode = True
elif o in ('-l', '--list'):
printtab = True
elif o in ('-C', '--cylinders'):
cylinders = int(a)
elif o in ('-H', '--heads'):
heads = int(a)
elif o in ('-S', '--sectors'):
sectors = int(a)
elif o in ('-D', '--dma'):
if a == 'iie':
gsvers = 0
elif a == 'gsrom01':
gsvers = 1
elif a == 'gsrom03':
gsvers = 3
elif a == 'off':
gsvers = 4
print('Bad mode {}'.format(a))
assert False, 'Unhandled option'
if assemble:
if len(args) == 0:
print('Need at least one input file to assemble')
if outfile == None:
print('Must specify output file with -o')
parttab['cyls'] = cylinders
parttab['heads'] = heads
parttab['sectors'] = sectors
parttab['gsvers'] = gsvers
assemble_mdt_image(outfile, args)
if len(args) == 0:
print('No input file provided')
if len(args) > 1:
print('Provide only one input file')
if printtab:
if explode: