static floperr_t put_bml3_dirent(imgtool_image *f, int index_loc, const struct bml3_dirent *ent)
{
floperr_t err;
UINT8 head, track, sector, offset;
UINT8 buf[32];
bml3_diskinfo *info = bml3_get_diskinfo(f);
if (index_loc >= max_dirents(f))
return (floperr_t)IMGTOOLERR_FILENOTFOUND;
dirent_location(f, index_loc, &head, &track, §or, &offset);
memset(buf, 0, sizeof(buf));
switch (info->variant) {
case 0:
memcpy(&buf[0], &ent->fname, 8);
buf[11] = ent->ftype;
buf[12] = ent->asciiflag;
buf[14] = ent->first_granule;
break;
case 1:
memcpy(&buf[0], &ent->fname, 8);
memcpy(&buf[8], &ent->fext, 3);
buf[11] = ent->ftype;
buf[12] = ent->asciiflag;
buf[13] = ent->first_granule;
buf[14] = ent->lastsectorbytes >> 8;
buf[15] = ent->lastsectorbytes & 0xff;
break;
default:
return FLOPPY_ERROR_INVALIDIMAGE;
}
err = floppy_write_sector(imgtool_floppy(f), head, track, sector, offset, (void *) buf, sizeof(buf), 0); /* TODO: pass ddam argument from imgtool */
return err;
}
static imgtoolerr_t imgtool_floppy_transfer_sector_tofrom_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f, int direction)
{
floperr_t err;
floppy_image_legacy *floppy;
dynamic_buffer buffer;
floppy = imgtool_floppy(img);
buffer.resize(length);
if (direction)
{
err = floppy_read_sector(floppy, head, track, sector, offset, buffer, length);
if (err)
goto done;
stream_write(f, buffer, length);
}
else
{
stream_read(f, buffer, length);
err = floppy_write_sector(floppy, head, track, sector, offset, buffer, length, 0); /* TODO: pass ddam argument from imgtool */
if (err)
goto done;
}
err = FLOPPY_ERROR_SUCCESS;
done:
return imgtool_floppy_error(err);
}
floperr_t floppy_clear_sector(floppy_image *floppy, int head, int track, int sector, UINT8 data)
{
floperr_t err;
UINT32 length;
UINT8 *buffer = NULL;
err = floppy_get_sector_length(floppy, head, track, sector, &length);
if (err)
goto done;
buffer = malloc(length);
if (err)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
goto done;
}
memset(buffer, data, length);
err = floppy_write_sector(floppy, head, track, sector, 0, buffer, length);
if (err)
goto done;
done:
if (buffer)
free(buffer);
return err;
}
void floppy_write(uint8_t * buf, size_t count, int offset) {
int offset_sector = offset / FLOPPY_SECTOR_SIZE;
int offset_in_sector = offset % FLOPPY_SECTOR_SIZE;
uint32_t cylinder;
uint32_t head;
uint32_t sector;
size_t c;
char buffer[FLOPPY_SECTOR_SIZE];
while (count) {
cylinder = offset_sector / (FLOPPY_SECTORS_PER_TRACK * FLOPPY_NB_HEADS);
head = (offset_sector % (FLOPPY_SECTORS_PER_TRACK * FLOPPY_NB_HEADS)) / (FLOPPY_SECTORS_PER_TRACK);
sector = (offset_sector % (FLOPPY_SECTORS_PER_TRACK * FLOPPY_NB_HEADS)) % (FLOPPY_SECTORS_PER_TRACK);
floppy_read_sector(cylinder, head, sector, buffer);
c = FLOPPY_SECTOR_SIZE - offset_in_sector;
if (count <= c) {
memcpy(buffer + offset_in_sector, buf, count);
count = 0;
} else {
memcpy(buffer + offset_in_sector, buf, c);
count -= c;
buf += c;
offset_in_sector = 0;
offset_sector++;
}
floppy_write_sector(cylinder, head, sector, buffer);
}
}
static imgtoolerr_t imgtool_floppy_write_sector(imgtool_image *image, UINT32 track, UINT32 head, UINT32 sector, const void *buffer, size_t len, int ddam)
{
floperr_t ferr;
ferr = floppy_write_sector(imgtool_floppy(image), head, track, sector, 0, buffer, len, ddam);
if (ferr)
return imgtool_floppy_error(ferr);
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t os9_write_lsn(imgtool_image *img, UINT32 lsn, int offset, const void *buffer, size_t buffer_len)
{
imgtoolerr_t err;
floperr_t ferr;
UINT32 head, track, sector;
err = os9_locate_lsn(img, lsn, &head, &track, §or);
if (err)
return err;
ferr = floppy_write_sector(imgtool_floppy(img), head, track, sector, offset, buffer, buffer_len, 0); /* TODO: pass ddam argument from imgtool */
if (ferr)
return imgtool_floppy_error(ferr);
return IMGTOOLERR_SUCCESS;
}
/* write data to sector */
static imgtoolerr_t vzdos_write_sector_data(imgtool_image *img, int track, int sector, UINT8 *data)
{
int ret, data_start;
UINT8 buffer[DATA_SIZE + 4]; /* data + checksum */
ret = vzdos_get_data_start(img, track, sector, &data_start);
if (ret) return (imgtoolerr_t)ret;
memcpy(buffer, data, DATA_SIZE + 2);
place_integer_le(buffer, DATA_SIZE + 2, 2, chksum16(data, DATA_SIZE + 2));
ret = floppy_write_sector(imgtool_floppy(img), 0, track, sector_order[sector], data_start, buffer, sizeof(buffer), 0); /* TODO: pass ddam argument from imgtool */
if (ret) return (imgtoolerr_t)ret;
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t vzdos_write_formatted_sector(imgtool_image *img, int track, int sector)
{
int ret;
UINT8 sector_data[DATA_SIZE + 4 + 24];
static const UINT8 sector_header[24] = {
0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0xFE, 0xE7,
0x18, 0xC3, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x00, 0xC3, 0x18, 0xE7, 0xFE
};
memset(sector_data, 0x00, sizeof(sector_data));
memcpy(sector_data, sector_header, sizeof(sector_header));
sector_data[10] = (UINT8) track; /* current track */
sector_data[11] = (UINT8) sector; /* current sector */
sector_data[12] = (UINT8) track + sector; /* checksum-8 */
ret = floppy_write_sector(imgtool_floppy(img), 0, track, sector_order[sector], 0, sector_data, sizeof(sector_data), 0); /* TODO: pass ddam argument from imgtool */
if (ret) return (imgtoolerr_t)ret;
return IMGTOOLERR_SUCCESS;
}
static imgtoolerr_t imgtool_floppy_transfer_sector_tofrom_stream(imgtool_image *img, int head, int track, int sector, int offset, size_t length, imgtool_stream *f, int direction)
{
floperr_t err;
floppy_image_legacy *floppy;
void *buffer = NULL;
floppy = imgtool_floppy(img);
buffer = malloc(length);
if (!buffer)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
goto done;
}
if (direction)
{
err = floppy_read_sector(floppy, head, track, sector, offset, buffer, length);
if (err)
goto done;
stream_write(f, buffer, length);
}
else
{
stream_read(f, buffer, length);
err = floppy_write_sector(floppy, head, track, sector, offset, buffer, length, 0); /* TODO: pass ddam argument from imgtool */
if (err)
goto done;
}
err = FLOPPY_ERROR_SUCCESS;
done:
if (buffer)
free(buffer);
return imgtool_floppy_error(err);
}
static floperr_t put_rsdos_dirent(imgtool::image &f, int index_loc, const rsdos_dirent &ent)
{
if (index_loc >= MAX_DIRENTS)
return (floperr_t)IMGTOOLERR_FILENOTFOUND;
return floppy_write_sector(imgtool_floppy(f), 0, 17, 3, index_loc * 32, (void *) &ent, sizeof(ent), 0); /* TODO: pass ddam argument from imgtool */
}
static floperr_t put_granule_map(imgtool::image &img, const uint8_t *granule_map, uint8_t granule_count)
{
return floppy_write_sector(imgtool_floppy(img), 0, 17, 2, 0, granule_map, granule_count, 0); /* TODO: pass ddam argument from imgtool */
}
static imgtoolerr_t os9_diskimage_create(imgtool_image *img, imgtool_stream *stream, option_resolution *opts)
{
imgtoolerr_t err;
dynamic_buffer header;
UINT32 heads, tracks, sectors, sector_bytes, first_sector_id;
UINT32 cluster_size, owner_id;
UINT32 allocation_bitmap_bits, allocation_bitmap_lsns;
UINT32 attributes, format_flags, disk_id;
UINT32 i;
INT32 total_allocated_sectors;
const char *title;
time_t t;
struct tm *ltime;
time(&t);
ltime = localtime(&t);
heads = option_resolution_lookup_int(opts, 'H');
tracks = option_resolution_lookup_int(opts, 'T');
sectors = option_resolution_lookup_int(opts, 'S');
sector_bytes = option_resolution_lookup_int(opts, 'L');
first_sector_id = option_resolution_lookup_int(opts, 'F');
title = "";
header.resize(sector_bytes);
if (sector_bytes > 256)
sector_bytes = 256;
cluster_size = 1;
owner_id = 1;
disk_id = 1;
attributes = 0;
allocation_bitmap_bits = heads * tracks * sectors / cluster_size;
allocation_bitmap_lsns = (allocation_bitmap_bits / 8 + sector_bytes - 1) / sector_bytes;
format_flags = ((heads > 1) ? 0x01 : 0x00) | ((tracks > 40) ? 0x02 : 0x00);
memset(&header[0], 0, sector_bytes);
place_integer_be(&header[0], 0, 3, heads * tracks * sectors);
place_integer_be(&header[0], 3, 1, sectors);
place_integer_be(&header[0], 4, 2, (allocation_bitmap_bits + 7) / 8);
place_integer_be(&header[0], 6, 2, cluster_size);
place_integer_be(&header[0], 8, 3, 1 + allocation_bitmap_lsns);
place_integer_be(&header[0], 11, 2, owner_id);
place_integer_be(&header[0], 13, 1, attributes);
place_integer_be(&header[0], 14, 2, disk_id);
place_integer_be(&header[0], 16, 1, format_flags);
place_integer_be(&header[0], 17, 2, sectors);
place_string(&header[0], 31, 32, title);
place_integer_be(&header[0], 103, 2, sector_bytes / 256);
/* path descriptor options */
place_integer_be(&header[0], 0x3f+0x00, 1, 1); /* device class */
place_integer_be(&header[0], 0x3f+0x01, 1, 1); /* drive number */
place_integer_be(&header[0], 0x3f+0x03, 1, 0x20); /* device type */
place_integer_be(&header[0], 0x3f+0x04, 1, 1); /* density capability */
place_integer_be(&header[0], 0x3f+0x05, 2, tracks); /* number of tracks */
place_integer_be(&header[0], 0x3f+0x07, 1, heads); /* number of sides */
place_integer_be(&header[0], 0x3f+0x09, 2, sectors); /* sectors per track */
place_integer_be(&header[0], 0x3f+0x0b, 2, sectors); /* sectors on track zero */
place_integer_be(&header[0], 0x3f+0x0d, 1, 3); /* sector interleave factor */
place_integer_be(&header[0], 0x3f+0x0e, 1, 8); /* default sectors per allocation */
err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id, 0, &header[0], sector_bytes, 0); /* TODO: pass ddam argument from imgtool */
if (err)
goto done;
total_allocated_sectors = 1 + allocation_bitmap_lsns + 1 + 7;
for (i = 0; i < allocation_bitmap_lsns; i++)
{
memset(&header[0], 0x00, sector_bytes);
if (total_allocated_sectors > (8 * 256))
{
memset(&header[0], 0xff, sector_bytes);
total_allocated_sectors -= (8 * 256);
}
else if (total_allocated_sectors > 1 )
{
int offset;
UINT8 mask;
while( total_allocated_sectors >= 0 )
{
offset = total_allocated_sectors / 8;
mask = 1 << (7 - ( total_allocated_sectors % 8 ) );
header[offset] |= mask;
total_allocated_sectors--;
}
}
err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id + 1 + i, 0, &header[0], sector_bytes, 0); /* TODO: pass ddam argument from imgtool */
if (err)
goto done;
}
memset(&header[0], 0, sector_bytes);
header[0x00] = 0xBF;
header[0x01] = 0x00;
header[0x02] = 0x00;
header[0x03] = (UINT8) ltime->tm_year;
header[0x04] = (UINT8) ltime->tm_mon + 1;
header[0x05] = (UINT8) ltime->tm_mday;
header[0x06] = (UINT8) ltime->tm_hour;
header[0x07] = (UINT8) ltime->tm_min;
header[0x08] = 0x02;
header[0x09] = 0x00;
header[0x0A] = 0x00;
header[0x0B] = 0x00;
header[0x0C] = 0x40;
header[0x0D] = (UINT8) (ltime->tm_year % 100);
header[0x0E] = (UINT8) ltime->tm_mon;
header[0x0F] = (UINT8) ltime->tm_mday;
place_integer_be(&header[0], 0x10, 3, 1 + allocation_bitmap_lsns + 1);
place_integer_be(&header[0], 0x13, 2, 8);
err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id + 1 + allocation_bitmap_lsns, 0, &header[0], sector_bytes, 0); /* TODO: pass ddam argument from imgtool */
if (err)
goto done;
memset(&header[0], 0, sector_bytes);
header[0x00] = 0x2E;
header[0x01] = 0xAE;
header[0x1F] = 1 + allocation_bitmap_lsns;
header[0x20] = 0xAE;
header[0x3F] = 1 + allocation_bitmap_lsns;
err = (imgtoolerr_t)floppy_write_sector(imgtool_floppy(img), 0, 0, first_sector_id + 2 + allocation_bitmap_lsns, 0, &header[0], sector_bytes, 0); /* TOOD: pass ddam argument from imgtool */
if (err)
goto done;
done:
return err;
}
static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, UINT8 granule_count)
{
return floppy_write_sector(imgtool_floppy(img), 0, 17, 2, 0, granule_map, granule_count, 0); /* TODO: pass ddam argument from imgtool */
}
static floperr_t write_granule(imgtool_image *img, UINT8 granule, int offset, int length, const UINT8 *buf)
{
UINT8 head, track, sector;
granule_location(img, granule, &head, &track, §or);
return floppy_write_sector(imgtool_floppy(img), head, track, sector, offset, buf, length, 0); /* TODO: pass ddam argument from imgtool */
}
static floperr_t put_granule_map(imgtool_image *img, const UINT8 *granule_map, UINT8 granule_count)
{
bml3_diskinfo *info = bml3_get_diskinfo(img);
return floppy_write_sector(imgtool_floppy(img), 0, 20, info->fat_start_sector, info->fat_start_offset, granule_map, granule_count, 0); /* TODO: pass ddam argument from imgtool */
}