machine.c

/* machine.c: Routines for handling the various machine types
   Copyright (c) 1999-2015 Philip Kendall

   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 2 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.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

   Author contact information:

   E-mail: philip-fuse@shadowmagic.org.uk

*/

#include <config.h>

#include <stdlib.h>
#include <string.h>

#include "event.h"
#include "fuse.h"
#include "infrastructure/startup_manager.h"
#include "machine.h"
#include "machines/machines.h"
#include "machines/scorpion.h"
#include "machines/spec128.h"
#include "machines/spec48.h"
#include "machines/specplus3.h"
#include "machines/tc2068.h"
#include "memory_pages.h"
#include "module.h"
#include "movie.h"
#include "peripherals/ula.h"
#include "pokefinder/pokemem.h"
#include "rzx.h"
#include "settings.h"
#include "snapshot.h"
#include "sound.h"
#include "tape.h"
#include "timer/timer.h"
#include "ui/ui.h"
#include "ui/uidisplay.h"
#include "utils.h"

fuse_machine_info **machine_types = NULL; // Array of available machines
int machine_count = 0;

fuse_machine_info *machine_current = NULL; // The currently selected machine
static int machine_location;    // Where is the current machine in machine_types[...]?

static int machine_add_machine(int (*init_function)(fuse_machine_info *machine));
static int machine_select_machine(fuse_machine_info *machine);
static void machine_set_const_timings(fuse_machine_info *machine);
static void machine_set_variable_timings(fuse_machine_info *machine);

static int machine_init_machines(void *context)
{
    int error;

    error = machine_add_machine(spec16_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(spec48_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(spec48_ntsc_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(spec128_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(specplus2_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(specplus2a_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(specplus3_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(specplus3e_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(tc2048_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(tc2068_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(ts2068_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(pentagon_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(pentagon512_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(pentagon1024_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(scorpion_init);
    if (error) {
        return error;
    }
    error = machine_add_machine(spec_se_init);
    if (error) {
        return error;
    }
    return 0;
}


static int machine_add_machine(int (*init_function)(fuse_machine_info *machine))
{
    fuse_machine_info *machine;
    int error;

    machine_count++;

    machine_types = libspectrum_renew(fuse_machine_info *, machine_types, machine_count);

    machine_types[machine_count - 1] = libspectrum_new(fuse_machine_info, 1);
    machine = machine_types[machine_count - 1];

    error = init_function(machine);
    if (error) {
        return error;
    }

    machine_set_const_timings(machine);

    machine->capabilities = libspectrum_machine_capabilities(machine->machine);

    return 0;
}


int machine_select(libspectrum_machine type)
{
    int i;
    int error;

    // Stop any ongoing RZX
    rzx_stop_recording();
    rzx_stop_playback(1);

    // We don't want to have to deal with screen size changes in the movie code
    // and recording movies where we change machines seems pretty obscure
    movie_stop();

    for (i = 0; i < machine_count; i++) {
        if (machine_types[i]->machine == type) {
            machine_location = i;
            error = machine_select_machine(machine_types[i]);

            if (!error) {
                return 0;
            }

            // If we couldn't select the new machine type, try falling back to plain old 48K
            if (type != LIBSPECTRUM_MACHINE_48) {
                  error = machine_select(LIBSPECTRUM_MACHINE_48);
            }

            // If that still didn't work, give up
            if (error) {
                  ui_error(UI_ERROR_ERROR, "can't select 48K machine. Giving up.");
                  fuse_abort();
            } else {
                  ui_error(UI_ERROR_INFO, "selecting 48K machine");
                  return 0;
            }
            return 0;
        }
    }
    ui_error(UI_ERROR_ERROR, "machine type %d unknown", type);
    return 1;
}


int machine_select_id(const char *id)
{
    int i, error;

    for (i = 0; i < machine_count; i++) {
        if (!strcmp(machine_types[i]->id, id)) {
            error = machine_select_machine(machine_types[i]);
            if (error) {
                return error;
            }
            return 0;
        }
    }
    ui_error(UI_ERROR_ERROR, "Machine id '%s' unknown", id);
    return 1;
}


const char *machine_get_id(libspectrum_machine type)
{
    int i;

    for (i = 0; i < machine_count; i++) {
        if (machine_types[i]->machine == type) {
            return machine_types[i]->id;
        }
    }
    return NULL;
}


static int machine_select_machine(fuse_machine_info *machine)
{
    int width, height;
    int capabilities;

    machine_current = machine;

    settings_set_string(&settings_current.start_machine, machine->id);

    tstates = 0;

    // Reset the event stack
    event_reset();
    event_add(0, timer_event);
    event_add(machine->timings.tstates_per_frame, spectrum_frame_event);

    sound_end();

    if (uidisplay_end()) {
        return 1;
    }

    capabilities = libspectrum_machine_capabilities(machine->machine);

    // Set screen sizes here
    if (capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_VIDEO) {
        width = DISPLAY_SCREEN_WIDTH;
        height = 2 * DISPLAY_SCREEN_HEIGHT;
    } else {
        width = DISPLAY_ASPECT_WIDTH;
        height = DISPLAY_SCREEN_HEIGHT;
    }

    if (uidisplay_init(width, height)) {
        return 1;
    }

    sound_init(settings_current.sound_device);

    // Do a hard reset
    if (machine_reset(1)) {
        return 1;
    }

    // And the dock menu item
    if (capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK) {
        ui_menu_activate(UI_MENU_ITEM_MEDIA_CARTRIDGE_DOCK_EJECT, 0);
    }

    // Reset any dialogue boxes etc. which contain machine-dependent state
    ui_widgets_reset();

    return 0;
}


int machine_load_rom_bank_from_buffer(memory_page *bank_map,
                                      int page_num,
                                      unsigned char *buffer,
                                      size_t length,
                                      int custom)
{
    size_t offset;
    libspectrum_byte *data = memory_pool_allocate(length);
    memory_page *page;

    memcpy(data, buffer, length);

    for (page = &bank_map[page_num * MEMORY_PAGES_IN_16K], offset = 0; offset < length; page++, offset += MEMORY_PAGE_SIZE) {
        page->offset = offset;
        page->page_num = page_num;
        page->page = data + offset;
        page->writable = 0;
        page->save_to_snapshot = custom;
    }
    return 0;
}


static int machine_load_rom_bank_from_file(memory_page *bank_map,
                                           int page_num,
                                           const char *filename,
                                           size_t expected_length,
                                           int custom)
{
    int error;
    utils_file rom;

    error = utils_read_auxiliary_file(filename, &rom, UTILS_AUXILIARY_ROM);
    if (error == -1) {
        ui_error(UI_ERROR_ERROR, "couldn't find ROM '%s'", filename);
        return 1;
    }
    if (error) {
        return error;
    }

    if (rom.length != expected_length) {
        ui_error(UI_ERROR_ERROR,
                 "ROM '%s' is %ld bytes long; expected %ld bytes",
                 filename,
                 (unsigned long)rom.length,
                 (unsigned long)expected_length);
        utils_close_file(&rom);
        return 1;
    }

    error = machine_load_rom_bank_from_buffer(bank_map, page_num, rom.buffer, rom.length, custom);

    utils_close_file(&rom);

    return error;
}


int machine_load_rom_bank(memory_page *bank_map,
                          int page_num,
                          const char *filename,
                          const char *fallback,
                          size_t expected_length)
{
    int custom = 0;
    int retval;

    if (fallback) {
        custom = !!strcmp(filename, fallback);
    }

    retval = machine_load_rom_bank_from_file(bank_map, page_num, filename, expected_length, custom);
    if (retval && fallback && custom) {
        retval = machine_load_rom_bank_from_file(bank_map, page_num, fallback, expected_length, 0);
    }
    return retval;
}


int machine_load_rom(int page_num, const char *filename, const char *fallback, size_t expected_length)
{
    return machine_load_rom_bank(memory_map_rom, page_num, filename, fallback, expected_length);
}


int machine_reset(int hard_reset)
{
    size_t i;
    int error;

    // Clear poke list (undoes effects of active pokes on Spectrum memory)
    pokemem_clear();

    sound_ay_reset();

    tape_stop();

    memory_pool_free();

    machine_current->ram.romcs = 0;

    machine_set_variable_timings(machine_current);

    memory_reset();

    // Do the machine-specific bits, including loading the ROMs
    error = machine_current->reset();
    if (error) {
        return error;
    }

    module_reset (hard_reset);

    error = machine_current->memory_map();
    if (error) {
        return error;
    }

    // Set up the contention array
    for (i = 0; i < machine_current->timings.tstates_per_frame; i++) {
        ula_contention[i] = machine_current->ram.contend_delay(i);
        ula_contention_no_mreq[i] = machine_current->ram.contend_delay_no_mreq(i);
    }

    // Update the disk menu items
    ui_menu_disk_update();

    // clear out old display image ready for new one
    display_refresh_all();

    return 0;
}


static void machine_set_const_timings(fuse_machine_info *machine)
{
    // Pull timings we use repeatedly out of libspectrum and store them for ourself
    machine->timings.processor_speed = libspectrum_timings_processor_speed(machine->machine);
    machine->timings.left_border = libspectrum_timings_left_border(machine->machine);
    machine->timings.horizontal_screen = libspectrum_timings_horizontal_screen(machine->machine);
    machine->timings.right_border = libspectrum_timings_right_border(machine->machine);
    machine->timings.tstates_per_line = libspectrum_timings_tstates_per_line(machine->machine);
    machine->timings.interrupt_length = libspectrum_timings_interrupt_length(machine->machine);
    machine->timings.tstates_per_frame = libspectrum_timings_tstates_per_frame(machine->machine);
}


static void machine_set_variable_timings(fuse_machine_info *machine)
{
    size_t y;

    /* Magic number alert

       libspectrum_timings_top_left_pixel gives us the number of tstates
       after the interrupt at which the top-left pixel of the screen is displayed.
       However, what's more useful for Fuse is when the first
       pixel of the top line of the border is displayed.

       Fuse shows DISPLAY_BORDER_HEIGHT lines of top border and
       DISPLAY_BORDER_WIDTH_COLS columns of left border,
       so we subtract the appropriate offset to get when the top-left pixel of the border is displayed.
    */

    machine->line_times[0] = libspectrum_timings_top_left_pixel(machine->machine) -
                             // DISPLAY_BORDER_HEIGHT lines of top border
                             (DISPLAY_BORDER_HEIGHT * machine->timings.tstates_per_line) -
                             (4 * DISPLAY_BORDER_WIDTH_COLS); // Left border at 4 tstates per column

    if (settings_current.late_timings) {
        machine->line_times[0]++;
    }

    for (y = 1; y < DISPLAY_SCREEN_HEIGHT + 1; y++) {
        machine->line_times[y] = machine->line_times[y - 1] + machine->timings.tstates_per_line;
    }
}


static void machine_end(void)
{
    int i;

    for (i = 0; i < machine_count; i++) {
        if (machine_types[i]->shutdown) {
            machine_types[i]->shutdown();
        }
        libspectrum_free(machine_types[i]);
    }

    libspectrum_free(machine_types);
}


void machine_register_startup(void)
{
    startup_manager_module dependencies[] = {
        STARTUP_MANAGER_MODULE_MEMORY,
        STARTUP_MANAGER_MODULE_SETUID
    };
    startup_manager_register(STARTUP_MANAGER_MODULE_MACHINE,
                             dependencies,
                             ARRAY_SIZE(dependencies),
                             machine_init_machines,
                             NULL,
                             machine_end);
}