source: buchla-emu/emu/mkdisk.c

/*
 *  Copyright (C) 2017 The Contributors
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or (at
 *  your option) any later version.
 *
 *  This program 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
 *  General Public License for more details.
 *
 *  A copy of the GNU General Public License can be found in the file
 *  "gpl.txt" in the top directory of this repository.
 */

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>

#define DISK_FILE_NAME "buchla.disk"
#define MIDAS_FILE_NAME "midas.abs"

#define N_CYL 80
#define N_SID 2
#define N_SEC 9
#define SZ_SEC 512

#define N_SEC_CLU 2
#define SZ_CLU (SZ_SEC * N_SEC_CLU)

#define N_BOOT_SEC 1
#define N_FAT_SEC 3
#define N_ROOT_SEC 7

#define N_FAT 2
#define SZ_DIR_ENT 32

#define ROOT_SEC (N_BOOT_SEC + N_FAT_SEC * N_FAT)
#define N_META_SEC (ROOT_SEC + N_ROOT_SEC)

static uint8_t midas[1024 * 1024];
static int32_t sz_midas;

static uint8_t disk[N_CYL * N_SID * N_SEC][SZ_SEC];

static int32_t put_sec_8(int32_t sec, int32_t off, int32_t val)
{
        disk[sec][off] = (uint8_t)val;
        return off + 1;
}

static int32_t put_sec_16(int32_t sec, int32_t off, int32_t val)
{
        disk[sec][off + 0] = (uint8_t)(val >> 0);
        disk[sec][off + 1] = (uint8_t)(val >> 8);
        return off + 2;
}

static int32_t put_sec_32(int32_t sec, int32_t off, int32_t val)
{
        off = put_sec_16(sec, off, val & 65535);
        off = put_sec_16(sec, off, val >> 16);
        return off;
}

static int32_t put_sec_str(int32_t sec, int32_t off, const char *str, int32_t len)
{
        int32_t i;

        for (i = 0;  str[i] != 0 && i < len; ++i) {
                disk[sec][off + i] = (uint8_t)str[i];
        }

        while (i < len) {
                disk[sec][off + i] = ' ';
                ++i;
        }

        return off + i;
}

static int32_t put_fat_12(int32_t sec, int32_t ent, int32_t val)
{
        uint8_t *fat = disk[sec];

        int32_t off = ent / 2 * 3;
        int32_t bit = (ent % 2) * 12;

        int32_t tmp = 0;

        tmp |= fat[off + 0] <<  0;
        tmp |= fat[off + 1] <<  8;
        tmp |= fat[off + 2] << 16;

        tmp = (tmp & ~(0xfff << bit)) | (val << bit);

        fat[off + 0] = (uint8_t)(tmp >>  0);
        fat[off + 1] = (uint8_t)(tmp >>  8);
        fat[off + 2] = (uint8_t)(tmp >> 16);

        return ent + 1;
}

static void init_boot_sector(void)
{
        int32_t off = 0;

        // magic number
        off = put_sec_8(0, off, 0xe9);
        off = put_sec_8(0, off, 0x00);

        // OEM
        off = put_sec_str(0, off, "EMUL", 6);

        // serial number
        off = put_sec_8(0, off, 0x01);
        off = put_sec_8(0, off, 0x02);
        off = put_sec_8(0, off, 0x03);

        // bytes per sector
        off = put_sec_16(0, off, SZ_SEC);

        // sectors per cluster
        off = put_sec_8(0, off, N_SEC_CLU);

        // number of reserved sectors
        off = put_sec_16(0, off, N_BOOT_SEC);

        // number of FATs
        off = put_sec_8(0, off, N_FAT);

        // maximum number of root directory entries
        off = put_sec_16(0, off, N_ROOT_SEC * SZ_SEC / SZ_DIR_ENT);

        // total number of sectors
        off = put_sec_16(0, off, N_CYL * N_SID * N_SEC);

        // media descriptor (floppy disk, 720k)
        off = put_sec_8(0, off, 0xf9);

        // sectors per FAT (9 * 512 / 3 * 2 = 3072)
        off = put_sec_16(0, off, N_FAT_SEC);

        // sectors per track
        off = put_sec_16(0, off, N_SEC);

        // number of sides
        off = put_sec_16(0, off, N_SID);

        // number of hidden sectors
        off = put_sec_16(0, off, 0);

        put_sec_8(0, SZ_SEC - 2, 0x55);
        put_sec_8(0, SZ_SEC - 1, 0xaa);
}

static void init_fat(int32_t sec)
{
        int32_t ent = 0;

        ent = put_fat_12(sec, ent, 0xff9);
        ent = put_fat_12(sec, ent, 0xfff);

        int32_t n_clu = (sz_midas + SZ_CLU - 1) / SZ_CLU;

        for (int32_t i = 0; i < n_clu - 1; ++i) {
                ent = put_fat_12(sec, ent, ent + 1);
        }

        put_fat_12(sec, ent, 0xfff);
}

static void init_midas(void)
{
        int32_t off = 0;

        // file name
        off = put_sec_str(ROOT_SEC, off, "MIDAS", 8);

        // extension
        off = put_sec_str(ROOT_SEC, off, "ABS", 3);

        // file attributes (0x20 = archive)
        off = put_sec_8(ROOT_SEC, off, 0x20);

        // unused
        for (int32_t i = 0; i < 10; ++i) {
                off = put_sec_8(ROOT_SEC, off, 0x00);
        }

        // last modified time (12:34:56)
        off = put_sec_16(ROOT_SEC, off, (12 << 11) | (34 << 5) | (56 / 2));

        // last modified date (1988-06-20)
        off = put_sec_16(ROOT_SEC, off, (8 << 9) | (6 << 5) | 20);

        // start cluster
        off = put_sec_16(ROOT_SEC, off, 2);

        // file size
        off = put_sec_32(ROOT_SEC, off, sz_midas);

        int32_t n_sec = (sz_midas + SZ_SEC - 1) / SZ_SEC;
        memcpy(disk[N_META_SEC], midas, (size_t)n_sec * SZ_SEC);
}

static void write_disk(void)
{
        FILE *fh = fopen(DISK_FILE_NAME, "wb");

        if (fh == NULL || fwrite(disk, sizeof disk, 1, fh) != 1) {
                fprintf(stderr, "error while writing disk file " DISK_FILE_NAME "\n");
                exit(1);
        }

        fclose(fh);
}

static void load_midas(void)
{
        FILE *fh = fopen(MIDAS_FILE_NAME, "rb");

        if (fh == NULL) {
                fprintf(stderr, "error while opening MIDAS file " MIDAS_FILE_NAME "\n");
                exit(1);
        }

        if (fseek(fh, 0, SEEK_END) < 0) {
                fprintf(stderr, "error while seeking in MIDAS file " MIDAS_FILE_NAME "\n");
                exit(1);
        }

        ssize_t len = ftell(fh);

        if (len < 0) {
                fprintf(stderr, "error while determining size of MIDAS file " MIDAS_FILE_NAME "\n");
                exit(1);
        }

        sz_midas = (int32_t)len;
        rewind(fh);

        if (fread(midas, (size_t)sz_midas, 1, fh) != 1) {
                fprintf(stderr, "error while reading MIDAS file " MIDAS_FILE_NAME "\n");
                exit(1);
        }

        fclose(fh);
}

int32_t main(int32_t argc, char *argv[])
{
        (void)argc;
        (void)argv;

        load_midas();
        init_boot_sector();

        for (int32_t i = 0; i < N_FAT; ++i) {
                init_fat(N_BOOT_SEC + i * N_FAT_SEC);
        }

        init_midas();
        write_disk();
        return 0;
}