eaw/Main
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Minimig: improve the config selector.

Browse Source
This commit is contained in:
sorgelig
2019-01-19 15:17:16 +08:00
parent 325f6b6ce4
commit e52d1c25f7
6 changed files with 296 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
menu.cpp
View File

@@ -152,9 +152,9 @@ const char *config_tos_mem[] = { "512 kB", "1 MB", "2 MB", "4 MB", "8 MB", "14 M
const char *config_tos_wrprot[] = { "none", "A:", "B:", "A: and B:" };
const char *config_tos_usb[] = { "none", "control", "debug", "serial", "parallel", "midi" };
const char *config_memory_chip_msg[] = { "512kb", "1mb", "1.5mb", "2mb" };
const char *config_memory_slow_msg[] = { "none", "512kb", "1mb", "1.5mb" };
const char *config_memory_fast_msg[] = { "none", "2mb", "4mb","24mb","24mb" };
const char *config_memory_chip_msg[] = { "512K", "1M", "1.5M", "2M" };
const char *config_memory_slow_msg[] = { "none", "512K", "1M", "1.5M" };
const char *config_memory_fast_msg[] = { "none", "2M", "4M", "24M" };
const char *config_scanlines_msg[] = { "off", "dim", "black" };
const char *config_ar_msg[] = { "4:3", "16:9" };
@@ -2301,7 +2301,7 @@ void HandleUI(void)
// We also print a help text in place of the last drive if it's inactive.
for (int i = 0; i < 4; i++)
{
if (i == config.floppy.drives + 1)
if (i == minimig_config.floppy.drives + 1)
OsdWrite(i+1, " KP +/- to add/remove drives", 0, 1);
else
{
@@ -2336,16 +2336,16 @@ void HandleUI(void)
strcat(s, "* no disk *");
}
}
else if (i <= config.floppy.drives)
else if (i <= minimig_config.floppy.drives)
{
strcat(s, "* active after reset *");
}
else
strcpy(s, "");
OsdWrite(i+1, s, menusub == (uint32_t)i, (i>drives) || (i>config.floppy.drives));
OsdWrite(i+1, s, menusub == (uint32_t)i, (i>drives) || (i>minimig_config.floppy.drives));
}
}
sprintf(s, " Floppy disk turbo : %s", config.floppy.speed ? "on" : "off");
sprintf(s, " Floppy disk turbo : %s", minimig_config.floppy.speed ? "on" : "off");
OsdWrite(5, s, menusub == 4, 0);
OsdWrite(6, "", 0, 0);
@@ -2368,16 +2368,16 @@ void HandleUI(void)
case MENU_MAIN2:
if (menu)
menustate = MENU_NONE1;
else if (plus && (config.floppy.drives<3))
else if (plus && (minimig_config.floppy.drives<3))
{
config.floppy.drives++;
ConfigFloppy(config.floppy.drives, config.floppy.speed);
minimig_config.floppy.drives++;
ConfigFloppy(minimig_config.floppy.drives, minimig_config.floppy.speed);
menustate = MENU_MAIN1;
}
else if (minus && (config.floppy.drives>0))
else if (minus && (minimig_config.floppy.drives>0))
{
config.floppy.drives--;
ConfigFloppy(config.floppy.drives, config.floppy.speed);
minimig_config.floppy.drives--;
ConfigFloppy(minimig_config.floppy.drives, minimig_config.floppy.speed);
menustate = MENU_MAIN1;
}
else if (select)
@@ -2398,8 +2398,8 @@ void HandleUI(void)
}
else if (menusub == 4) // Toggle floppy turbo
{
config.floppy.speed ^= 1;
ConfigFloppy(config.floppy.drives, config.floppy.speed);
minimig_config.floppy.speed ^= 1;
ConfigFloppy(minimig_config.floppy.drives, minimig_config.floppy.speed);
menustate = MENU_MAIN1;
}
else if (menusub == 5) // Go to harddrives page.
@@ -2463,27 +2463,42 @@ void HandleUI(void)
case MENU_LOADCONFIG_1:
helptext = helptexts[HELPTEXT_NONE];
if (parentstate != menustate)
{
menumask = 0x400;
for (int i = 0; i < 10; i++) if (GetConfigDisplayName(i)) menumask |= 1<<i;
}
if (parentstate != menustate) menumask = 0x400;
parentstate = menustate;
OsdSetTitle("Load config", 0);
OsdWrite(0, "", 0, 0);
OsdWrite(1, "", 0, 0);
OsdWrite(2, " Default", menusub == 0, (menumask & 1) == 0);
OsdWrite(3, "", 0, 0);
for (uint i = 1; i < 10; i++)
m = 0;
OsdWrite(m++, "", 0, 0);
OsdWrite(m++, " Startup config:");
for (uint i = 0; i < 10; i++)
{
static char name[64];
sprintf(name, " %d ", i);
if (menumask & (1 << i)) strcat(name, GetConfigDisplayName(i));
OsdWrite(3+i, name, menusub == i, !(menumask & (1 << i)));
const char *info = minimig_GetCfgInfo(i);
static char name[128];
if (info)
{
menumask |= 1 << i;
sprintf(name, " %s", strlen(info) ? info : "NO INFO");
char *p = strchr(name, '\n');
if (p) *p = 0;
OsdWrite(m++, name, menusub == i);
if (menusub == i && p)
{
sprintf(name, " %s", strchr(info, '\n')+1);
OsdWrite(m++, name, 1, !(menumask & (1 << i)));
}
}
if (!i)
{
OsdWrite(m++, "", 0, 0);
m = 4;
OsdWrite(m++, " Other configs:");
}
}
for (int i = 13; i < OsdGetSize() - 1; i++) OsdWrite(i, "", 0, 0);
while(m < OsdGetSize() - 1) OsdWrite(m++);
OsdWrite(OsdGetSize() - 1, STD_EXIT, menusub == 10, 0);
menustate = MENU_LOADCONFIG_2;
@@ -2500,7 +2515,7 @@ void HandleUI(void)
if (menusub<10)
{
OsdDisable();
LoadConfiguration(menusub);
minimig_LoadCfg(menusub);
menustate = MENU_NONE1;
}
else
@@ -2696,21 +2711,40 @@ void HandleUI(void)
parentstate = menustate;
OsdSetTitle("Save config", 0);
OsdWrite(0, "", 0, 0);
OsdWrite(1, "", 0, 0);
OsdWrite(2, " Default", menusub == 0, 0);
OsdWrite(3, "", 0, 0);
for (uint i = 1; i < 10; i++)
m = 0;
OsdWrite(m++, "", 0, 0);
OsdWrite(m++, " Startup config:");
for (uint i = 0; i < 10; i++)
{
static char name[64];
sprintf(name, " %d ", i);
const char *cfgname = GetConfigDisplayName(i);
if (cfgname) strcat(name, GetConfigDisplayName(i));
OsdWrite(3 + i, name, menusub == i, !(menumask & (1 << i)));
const char *info = minimig_GetCfgInfo(i);
static char name[128];
if (info)
{
sprintf(name, " %s", strlen(info) ? info : "NO INFO");
char *p = strchr(name, '\n');
if (p) *p = 0;
OsdWrite(m++, name, menusub == i);
if (menusub == i && p)
{
sprintf(name, " %s", strchr(info, '\n') + 1);
OsdWrite(m++, name, 1);
}
}
else
{
OsdWrite(m++, " < EMPTY >", menusub == i);
}
if (!i)
{
OsdWrite(m++, "", 0, 0);
m = 4;
OsdWrite(m++, " Other configs:");
}
}
for (int i = 13; i < OsdGetSize() - 1; i++) OsdWrite(i, "", 0, 0);
while (m < OsdGetSize() - 1) OsdWrite(m++);
OsdWrite(OsdGetSize() - 1, STD_EXIT, menusub == 10, 0);
menustate = MENU_SAVECONFIG_2;
@@ -2719,7 +2753,29 @@ void HandleUI(void)
case MENU_SAVECONFIG_2:
if (select)
{
if (menusub<10) SaveConfiguration(menusub);
sprintf(minimig_config.info, "%s/%s/%s%s %s+%s%s%s%s\n",
config_cpu_msg[minimig_config.cpu & 0x03] + 2,
config_chipset_msg[(minimig_config.chipset >> 2) & 7],
minimig_config.chipset & CONFIG_NTSC ? "N" : "P",
(minimig_config.enable_ide && (minimig_config.hardfile[0].enabled ||
minimig_config.hardfile[1].enabled ||
minimig_config.hardfile[2].enabled ||
minimig_config.hardfile[3].enabled)) ? "/HD" : "",
config_memory_chip_msg[minimig_config.memory & 0x03],
config_memory_fast_msg[(minimig_config.memory >> 4) & 0x03],
((minimig_config.memory >> 2) & 0x03) ? "+" : "",
((minimig_config.memory >> 2) & 0x03) ? config_memory_slow_msg[(minimig_config.memory >> 2) & 0x03] : "",
(minimig_config.memory & 0x40) ? " HRT" : ""
);
char *p = strrchr(minimig_config.kickstart, '/');
if (!p) p = minimig_config.kickstart;
else p++;
strncat(minimig_config.info, p, sizeof(minimig_config.info) - strlen(minimig_config.info) - 1);
minimig_config.info[sizeof(minimig_config.info) - 1] = 0;
if (menusub<10) minimig_SaveCfg(menusub);
menustate = MENU_MAIN1;
menusub = 9;
}
@@ -2741,24 +2797,24 @@ void HandleUI(void)
OsdWrite(0, "", 0, 0);
strcpy(s, " CPU : ");
strcat(s, config_cpu_msg[config.cpu & 0x03]);
strcat(s, config_cpu_msg[minimig_config.cpu & 0x03]);
OsdWrite(1, s, menusub == 0, 0);
strcpy(s, " Turbo : ");
strcat(s, config_turbo_msg[(config.cpu >> 2) & 0x03]);
strcat(s, config_turbo_msg[(minimig_config.cpu >> 2) & 0x03]);
OsdWrite(2, s, menusub == 1, 0);
OsdWrite(3, "", 0, 0);
strcpy(s, " Video : ");
strcat(s, config.chipset & CONFIG_NTSC ? "NTSC" : "PAL");
strcat(s, minimig_config.chipset & CONFIG_NTSC ? "NTSC" : "PAL");
OsdWrite(4, s, menusub == 2, 0);
strcpy(s, " Chipset : ");
strcat(s, config_chipset_msg[(config.chipset >> 2) & 7]);
strcat(s, config_chipset_msg[(minimig_config.chipset >> 2) & 7]);
OsdWrite(5, s, menusub == 3, 0);
OsdWrite(6, "", 0, 0);
strcpy(s, " CD32Pad : ");
strcat(s, config_cd32pad_msg[(config.autofire >> 2) & 1]);
strcat(s, config_cd32pad_msg[(minimig_config.autofire >> 2) & 1]);
OsdWrite(7, s, menusub == 4, 0);
strcpy(s, " Joy Swap : ");
strcat(s, (config.autofire & 0x8)? "ON" : "OFF");
strcat(s, (minimig_config.autofire & 0x8)? "ON" : "OFF");
OsdWrite(8, s, menusub == 5, 0);
for (int i = 9; i < OsdGetSize() - 1; i++) OsdWrite(i, "", 0, 0);
OsdWrite(OsdGetSize() - 1, STD_EXIT, menusub == 6, 0);
@@ -2785,57 +2841,57 @@ void HandleUI(void)
if (menusub == 0)
{
menustate = MENU_SETTINGS_CHIPSET1;
int _config_cpu = config.cpu & 0x3;
int _config_cpu = minimig_config.cpu & 0x3;
_config_cpu += 1;
if (_config_cpu == 0x02) _config_cpu += 1;
config.cpu = (config.cpu & 0xfc) | (_config_cpu & 0x3);
ConfigCPU(config.cpu);
minimig_config.cpu = (minimig_config.cpu & 0xfc) | (_config_cpu & 0x3);
ConfigCPU(minimig_config.cpu);
}
else if (menusub == 1)
{
menustate = MENU_SETTINGS_CHIPSET1;
int _config_turbo = (config.cpu >> 2) & 0x3;
int _config_turbo = (minimig_config.cpu >> 2) & 0x3;
_config_turbo += 1;
config.cpu = (config.cpu & 0x3) | ((_config_turbo & 0x3) << 2);
ConfigCPU(config.cpu);
minimig_config.cpu = (minimig_config.cpu & 0x3) | ((_config_turbo & 0x3) << 2);
ConfigCPU(minimig_config.cpu);
}
else if (menusub == 2)
{
config.chipset ^= CONFIG_NTSC;
minimig_config.chipset ^= CONFIG_NTSC;
menustate = MENU_SETTINGS_CHIPSET1;
ConfigChipset(config.chipset);
ConfigChipset(minimig_config.chipset);
}
else if (menusub == 3)
{
switch (config.chipset & 0x1c) {
switch (minimig_config.chipset & 0x1c) {
case 0:
config.chipset = (config.chipset & 3) | CONFIG_A1000;
minimig_config.chipset = (minimig_config.chipset & 3) | CONFIG_A1000;
break;
case CONFIG_A1000:
config.chipset = (config.chipset & 3) | CONFIG_ECS;
minimig_config.chipset = (minimig_config.chipset & 3) | CONFIG_ECS;
break;
case CONFIG_ECS:
config.chipset = (config.chipset & 3) | CONFIG_AGA | CONFIG_ECS;
minimig_config.chipset = (minimig_config.chipset & 3) | CONFIG_AGA | CONFIG_ECS;
break;
case (CONFIG_AGA | CONFIG_ECS) :
config.chipset = (config.chipset & 3) | 0;
minimig_config.chipset = (minimig_config.chipset & 3) | 0;
break;
}
menustate = MENU_SETTINGS_CHIPSET1;
ConfigChipset(config.chipset);
ConfigChipset(minimig_config.chipset);
}
else if (menusub == 4)
{
config.autofire ^= 0x4;
minimig_config.autofire ^= 0x4;
menustate = MENU_SETTINGS_CHIPSET1;
ConfigAutofire(config.autofire, 0x4);
ConfigAutofire(minimig_config.autofire, 0x4);
}
else if (menusub == 5)
{
config.autofire ^= 0x8;
minimig_config.autofire ^= 0x8;
menustate = MENU_SETTINGS_CHIPSET1;
ConfigAutofire(config.autofire, 0x8);
ConfigAutofire(minimig_config.autofire, 0x8);
}
else if (menusub == 6)
{
@@ -2873,23 +2929,23 @@ void HandleUI(void)
OsdWrite(0, "", 0, 0);
strcpy(s, " CHIP : ");
strcat(s, config_memory_chip_msg[config.memory & 0x03]);
strcat(s, config_memory_chip_msg[minimig_config.memory & 0x03]);
OsdWrite(1, s, menusub == 0, 0);
strcpy(s, " SLOW : ");
strcat(s, config_memory_slow_msg[config.memory >> 2 & 0x03]);
OsdWrite(2, s, menusub == 1, 0);
strcpy(s, " FAST : ");
strcat(s, config_memory_fast_msg[config.memory >> 4 & 0x03]);
strcat(s, config_memory_fast_msg[(minimig_config.memory >> 4) & 0x03]);
OsdWrite(2, s, menusub == 1, 0);
strcpy(s, " SLOW : ");
strcat(s, config_memory_slow_msg[(minimig_config.memory >> 2) & 0x03]);
OsdWrite(3, s, menusub == 2, 0);
OsdWrite(4, "", 0, 0);
strcpy(s, " ROM : ");
strncat(s, config.kickstart, 24);
strncat(s, minimig_config.kickstart, 24);
OsdWrite(5, s, menusub == 3, 0);
strcpy(s, " HRTmon : ");
strcat(s, (config.memory & 0x40) ? "enabled " : "disabled");
strcat(s, (minimig_config.memory & 0x40) ? "enabled " : "disabled");
OsdWrite(6, s, menusub == 4, 0);
for (int i = 7; i < OsdGetSize() - 1; i++) OsdWrite(i, "", 0, 0);
@@ -2903,17 +2959,17 @@ void HandleUI(void)
{
if (menusub == 0)
{
config.memory = ((config.memory + 1) & 0x03) | (config.memory & ~0x03);
minimig_config.memory = ((minimig_config.memory + 1) & 0x03) | (minimig_config.memory & ~0x03);
menustate = MENU_SETTINGS_MEMORY1;
}
else if (menusub == 1)
{
config.memory = ((config.memory + 4) & 0x0C) | (config.memory & ~0x0C);
minimig_config.memory = ((minimig_config.memory + 0x10) & 0x30) | (minimig_config.memory & ~0x30);
menustate = MENU_SETTINGS_MEMORY1;
}
else if (menusub == 2)
{
config.memory = ((config.memory + 0x10) & 0x30) | (config.memory & ~0x30);
minimig_config.memory = ((minimig_config.memory + 4) & 0x0C) | (minimig_config.memory & ~0x0C);
menustate = MENU_SETTINGS_MEMORY1;
}
else if (menusub == 3)
@@ -2922,7 +2978,7 @@ void HandleUI(void)
}
else if (menusub == 4)
{
config.memory ^= 0x40;
minimig_config.memory ^= 0x40;
menustate = MENU_SETTINGS_MEMORY1;
}
else if (menusub == 5)
@@ -2968,10 +3024,10 @@ void HandleUI(void)
parentstate = menustate;
menumask = 0x201; // b001000000001 - On/off & exit enabled by default...
if (config.enable_ide) menumask |= 0xAA; // b010101010 - HD0/1/2/3 type
if (minimig_config.enable_ide) menumask |= 0xAA; // b010101010 - HD0/1/2/3 type
OsdWrite(0, "", 0, 0);
strcpy(s, " A600/A1200 IDE : ");
strcat(s, config.enable_ide ? "On " : "Off");
strcat(s, minimig_config.enable_ide ? "On " : "Off");
OsdWrite(1, s, menusub == 0, 0);
OsdWrite(2, "", 0, 0);
@@ -2981,18 +3037,18 @@ void HandleUI(void)
{
strcpy(s, (i & 2) ? " Secondary " : " Primary ");
strcat(s, (i & 1) ? "Slave: " : "Master: ");
strcat(s, config.hardfile[i].enabled ? "Enabled" : "Disabled");
OsdWrite(n++, s, config.enable_ide ? (menusub == m++) : 0, config.enable_ide == 0);
if (config.hardfile[i].filename[0])
strcat(s, minimig_config.hardfile[i].enabled ? "Enabled" : "Disabled");
OsdWrite(n++, s, minimig_config.enable_ide ? (menusub == m++) : 0, minimig_config.enable_ide == 0);
if (minimig_config.hardfile[i].filename[0])
{
strcpy(s, " ");
strncpy(&s[7], config.hardfile[i].filename, 21);
strncpy(&s[7], minimig_config.hardfile[i].filename, 21);
}
else
{
strcpy(s, " ** not selected **");
}
enable = config.enable_ide && config.hardfile[i].enabled;
enable = minimig_config.enable_ide && minimig_config.hardfile[i].enabled;
if (enable) menumask |= t; // Make hardfile selectable
OsdWrite(n++, s, menusub == m++, enable == 0);
t <<= 2;
@@ -3009,7 +3065,7 @@ void HandleUI(void)
{
if (menusub == 0)
{
config.enable_ide = (config.enable_ide == 0);
minimig_config.enable_ide = (minimig_config.enable_ide == 0);
menustate = MENU_SETTINGS_HARDFILE1;
}
else if (menusub < 9)
@@ -3017,7 +3073,7 @@ void HandleUI(void)
if(menusub&1)
{
int num = (menusub - 1) / 2;
config.hardfile[num].enabled = config.hardfile[num].enabled ? 0 : 1;
minimig_config.hardfile[num].enabled = minimig_config.hardfile[num].enabled ? 0 : 1;
menustate = MENU_SETTINGS_HARDFILE1;
}
else
@@ -3056,10 +3112,10 @@ void HandleUI(void)
{
int num = (menusub - 2) / 2;
uint len = strlen(SelectedPath);
if (len > sizeof(config.hardfile[num].filename) - 1) len = sizeof(config.hardfile[num].filename) - 1;
if(len) memcpy(config.hardfile[num].filename, SelectedPath, len);
config.hardfile[num].filename[len] = 0;
menustate = checkHDF(config.hardfile[num].filename, &rdb) ? MENU_SETTINGS_HARDFILE1 : MENU_HARDFILE_SELECTED2;
if (len > sizeof(minimig_config.hardfile[num].filename) - 1) len = sizeof(minimig_config.hardfile[num].filename) - 1;
if(len) memcpy(minimig_config.hardfile[num].filename, SelectedPath, len);
minimig_config.hardfile[num].filename[len] = 0;
menustate = checkHDF(minimig_config.hardfile[num].filename, &rdb) ? MENU_SETTINGS_HARDFILE1 : MENU_HARDFILE_SELECTED2;
}
break;
@@ -3124,17 +3180,17 @@ void HandleUI(void)
OsdSetTitle("Video", OSD_ARROW_LEFT | OSD_ARROW_RIGHT);
OsdWrite(0, "", 0, 0);
strcpy(s, " Scanlines : ");
strcat(s, config_scanlines_msg[config.scanlines & 0x3]);
strcat(s, config_scanlines_msg[minimig_config.scanlines & 0x3]);
OsdWrite(1, s, menusub == 0, 0);
strcpy(s, " Video area by : ");
strcat(s, config_blank_msg[(config.scanlines >> 6) & 3]);
strcat(s, config_blank_msg[(minimig_config.scanlines >> 6) & 3]);
OsdWrite(2, s, menusub == 1, 0);
strcpy(s, " Aspect Ratio : ");
strcat(s, config_ar_msg[(config.scanlines >> 4) & 1]);
strcat(s, config_ar_msg[(minimig_config.scanlines >> 4) & 1]);
OsdWrite(3, s, menusub == 2, 0);
OsdWrite(4, "", 0, 0);
strcpy(s, " Stereo mix : ");
strcat(s, config_stereo_msg[config.audio & 3]);
strcat(s, config_stereo_msg[minimig_config.audio & 3]);
OsdWrite(5, s, menusub == 3, 0);
OsdWrite(6, "", 0, 0);
OsdWrite(7, "", 0, 0);
@@ -3155,30 +3211,30 @@ void HandleUI(void)
{
if (menusub == 0)
{
config.scanlines = ((config.scanlines + 1) & 0x03) | (config.scanlines & 0xfc);
if ((config.scanlines & 0x03) > 2) config.scanlines = config.scanlines & 0xfc;
minimig_config.scanlines = ((minimig_config.scanlines + 1) & 0x03) | (minimig_config.scanlines & 0xfc);
if ((minimig_config.scanlines & 0x03) > 2) minimig_config.scanlines = minimig_config.scanlines & 0xfc;
menustate = MENU_SETTINGS_VIDEO1;
ConfigVideo(config.filter.hires, config.filter.lores, config.scanlines);
ConfigVideo(minimig_config.filter.hires, minimig_config.filter.lores, minimig_config.scanlines);
}
else if (menusub == 1)
{
config.scanlines &= ~0x80;
config.scanlines ^= 0x40;
minimig_config.scanlines &= ~0x80;
minimig_config.scanlines ^= 0x40;
menustate = MENU_SETTINGS_VIDEO1;
ConfigVideo(config.filter.hires, config.filter.lores, config.scanlines);
ConfigVideo(minimig_config.filter.hires, minimig_config.filter.lores, minimig_config.scanlines);
}
else if (menusub == 2)
{
config.scanlines &= ~0x20; // reserved for auto-ar
config.scanlines ^= 0x10;
minimig_config.scanlines &= ~0x20; // reserved for auto-ar
minimig_config.scanlines ^= 0x10;
menustate = MENU_SETTINGS_VIDEO1;
ConfigVideo(config.filter.hires, config.filter.lores, config.scanlines);
ConfigVideo(minimig_config.filter.hires, minimig_config.filter.lores, minimig_config.scanlines);
}
else if (menusub == 3)
{
config.audio = (config.audio + 1) & 3;
minimig_config.audio = (minimig_config.audio + 1) & 3;
menustate = MENU_SETTINGS_VIDEO1;
ConfigAudio(config.audio);
ConfigAudio(minimig_config.audio);
}
else if (menusub == 4)
{

4
support/minimig/minimig_boot.cpp
View File

@@ -444,8 +444,8 @@ void BootInit()
BootPrintEx(" ");
}
config.kickstart[0] = 0;
LoadConfiguration(0);
minimig_config.kickstart[0] = 0;
minimig_LoadCfg(0);
}
void BootPrintEx(const char * str)

234
support/minimig/minimig_config.cpp
View File

@@ -7,36 +7,36 @@
#include <dirent.h>
#include "../../hardware.h"
#include "minimig_boot.h"
#include "../../file_io.h"
#include "../../osd.h"
#include "minimig_fdd.h"
#include "minimig_hdd.h"
#include "../../menu.h"
#include "minimig_config.h"
#include "../../user_io.h"
#include "../../input.h"
#include "minimig_boot.h"
#include "minimig_fdd.h"
#include "minimig_hdd.h"
#include "minimig_config.h"
typedef struct
{
char id[8];
unsigned long version;
char kickstart[1024];
filterTYPE filter;
unsigned char memory;
unsigned char chipset;
floppyTYPE floppy;
unsigned char disable_ar3;
unsigned char enable_ide;
unsigned char scanlines;
unsigned char audio;
hardfileTYPE hardfile[2];
unsigned char cpu;
unsigned char autofire;
char id[8];
unsigned long version;
char kickstart[1024];
mm_filterTYPE filter;
unsigned char memory;
unsigned char chipset;
mm_floppyTYPE floppy;
unsigned char disable_ar3;
unsigned char enable_ide;
unsigned char scanlines;
unsigned char audio;
mm_hardfileTYPE hardfile[2];
unsigned char cpu;
unsigned char autofire;
} configTYPE_old;
configTYPE config = { };
unsigned char romkey[3072];
mm_configTYPE minimig_config = { };
static unsigned char romkey[3072];
static void SendFileV2(fileTYPE* file, unsigned char* key, int keysize, int address, int size)
{
@@ -194,11 +194,11 @@ static char UploadActionReplay()
spi8((data >> 0) & 0xff);
data = 0x01; // key, 1 byte
spi8((data >> 0) & 0xff);
data = config.enable_ide ? 1 : 0; // ide, 1 byte
data = minimig_config.enable_ide ? 1 : 0; // ide, 1 byte
spi8((data >> 0) & 0xff);
data = 0x01; // a1200, 1 byte
spi8((data >> 0) & 0xff);
data = config.chipset&CONFIG_AGA ? 1 : 0; // aga, 1 byte
data = minimig_config.chipset&CONFIG_AGA ? 1 : 0; // aga, 1 byte
spi8((data >> 0) & 0xff);
data = 0x01; // insert, 1 byte
spi8((data >> 0) & 0xff);
@@ -208,7 +208,7 @@ static char UploadActionReplay()
spi8((data >> 0) & 0xff);
data = 0x00; // cd32, 1 byte
spi8((data >> 0) & 0xff);
data = config.chipset&CONFIG_NTSC ? 1 : 0; // screenmode, 1 byte
data = minimig_config.chipset&CONFIG_NTSC ? 1 : 0; // screenmode, 1 byte
spi8((data >> 0) & 0xff);
data = 1; // novbr, 1 byte
spi8((data >> 0) & 0xff);
@@ -219,7 +219,7 @@ static char UploadActionReplay()
DisableOsd();
adr = 0xa10000 + 68;
spi_osd_cmd32le_cont(OSD_CMD_WR, adr);
data = ((config.memory & 0x3) + 1) * 512 * 1024; // maxchip, 4 bytes TODO is this correct?
data = ((minimig_config.memory & 0x3) + 1) * 512 * 1024; // maxchip, 4 bytes TODO is this correct?
spi8((data >> 24) & 0xff); spi8((data >> 16) & 0xff);
spi8((data >> 8) & 0xff); spi8((data >> 0) & 0xff);
DisableOsd();
@@ -234,60 +234,30 @@ static char UploadActionReplay()
return(0);
}
static char* GetConfigurationName(int num)
static char* GetConfigurationName(int num, int chk)
{
static char path[128];
sprintf(path, "%s/%s", getRootDir(), CONFIG_DIR);
static char name[128];
if (num) sprintf(name, CONFIG_DIR "/minimig%d.cfg", num);
else sprintf(name, CONFIG_DIR "/minimig.cfg");
DIR *d;
struct dirent *dir;
d = opendir(path);
if (d)
{
if(num) sprintf(path, "minimig%d", num);
else sprintf(path, "minimig.cfg");
while ((dir = readdir(d)) != NULL)
{
int len = strlen(dir->d_name);
if (len>10 && !strncasecmp(dir->d_name, path, strlen(path)) && !strcasecmp(dir->d_name+len-4, ".cfg"))
{
closedir(d);
strcpy(path, dir->d_name);
return path;
}
}
closedir(d);
}
return NULL;
if (chk && !S_ISREG(getFileType(name))) return 0;
return name+strlen(CONFIG_DIR)+1;
}
unsigned char SaveConfiguration(int num)
int minimig_SaveCfg(int num)
{
const char *filename = GetConfigurationName(num);
if (!filename)
{
static char name[32];
if (num) sprintf(name, "minimig%d.cfg", num);
else sprintf(name, "minimig.cfg");
filename = name;
}
return FileSaveConfig(filename, &config, sizeof(config));
return FileSaveConfig(GetConfigurationName(num, 0), &minimig_config, sizeof(minimig_config));
}
const char* GetConfigDisplayName(int num)
const char* minimig_GetCfgInfo(int num)
{
char *filename = GetConfigurationName(num);
char *filename = GetConfigurationName(num, 1);
if (!filename) return NULL;
filename[strlen(filename) - 4] = 0;
char *p = strchr(filename, '_');
if (p) return p+1;
static mm_configTYPE tmpconf;
memset(&tmpconf, 0, sizeof(tmpconf));
if (FileLoadConfig(filename, &tmpconf, sizeof(tmpconf))) return tmpconf.info;
return "";
}
@@ -297,57 +267,57 @@ static void ApplyConfiguration(char reloadkickstart)
if (force_reload_kickstart) reloadkickstart = 1;
force_reload_kickstart = 0;
ConfigCPU(config.cpu);
ConfigCPU(minimig_config.cpu);
if (!reloadkickstart)
{
ConfigChipset(config.chipset);
ConfigFloppy(config.floppy.drives, config.floppy.speed);
ConfigChipset(minimig_config.chipset);
ConfigFloppy(minimig_config.floppy.drives, minimig_config.floppy.speed);
}
printf("CPU clock : %s\n", config.chipset & 0x01 ? "turbo" : "normal");
printf("Chip RAM size : %s\n", config_memory_chip_msg[config.memory & 0x03]);
printf("Slow RAM size : %s\n", config_memory_slow_msg[config.memory >> 2 & 0x03]);
printf("Fast RAM size : %s\n", config_memory_fast_msg[config.memory >> 4 & 0x03]);
printf("CPU clock : %s\n", minimig_config.chipset & 0x01 ? "turbo" : "normal");
printf("Chip RAM size : %s\n", config_memory_chip_msg[minimig_config.memory & 0x03]);
printf("Slow RAM size : %s\n", config_memory_slow_msg[minimig_config.memory >> 2 & 0x03]);
printf("Fast RAM size : %s\n", config_memory_fast_msg[minimig_config.memory >> 4 & 0x03]);
printf("Floppy drives : %u\n", config.floppy.drives + 1);
printf("Floppy speed : %s\n", config.floppy.speed ? "fast" : "normal");
printf("Floppy drives : %u\n", minimig_config.floppy.drives + 1);
printf("Floppy speed : %s\n", minimig_config.floppy.speed ? "fast" : "normal");
printf("\n");
printf("\nIDE state: %s.\n", config.enable_ide ? "enabled" : "disabled");
if (config.enable_ide)
printf("\nIDE state: %s.\n", minimig_config.enable_ide ? "enabled" : "disabled");
if (minimig_config.enable_ide)
{
printf("Primary Master HDD is %s.\n", config.hardfile[0].enabled ? "enabled" : "disabled");
printf("Primary Slave HDD is %s.\n", config.hardfile[1].enabled ? "enabled" : "disabled");
printf("Secondary Master HDD is %s.\n", config.hardfile[2].enabled ? "enabled" : "disabled");
printf("Secondary Slave HDD is %s.\n", config.hardfile[3].enabled ? "enabled" : "disabled");
printf("Primary Master HDD is %s.\n", minimig_config.hardfile[0].enabled ? "enabled" : "disabled");
printf("Primary Slave HDD is %s.\n", minimig_config.hardfile[1].enabled ? "enabled" : "disabled");
printf("Secondary Master HDD is %s.\n", minimig_config.hardfile[2].enabled ? "enabled" : "disabled");
printf("Secondary Slave HDD is %s.\n", minimig_config.hardfile[3].enabled ? "enabled" : "disabled");
}
rstval = SPI_CPU_HLT;
spi_osd_cmd8(OSD_CMD_RST, rstval);
spi_osd_cmd8(OSD_CMD_HDD, (config.enable_ide ? 1 : 0) | (OpenHardfile(0) ? 2 : 0) | (OpenHardfile(1) ? 4 : 0) | (OpenHardfile(2) ? 8 : 0) | (OpenHardfile(3) ? 16 : 0));
spi_osd_cmd8(OSD_CMD_HDD, (minimig_config.enable_ide ? 1 : 0) | (OpenHardfile(0) ? 2 : 0) | (OpenHardfile(1) ? 4 : 0) | (OpenHardfile(2) ? 8 : 0) | (OpenHardfile(3) ? 16 : 0));
ConfigMemory(config.memory);
ConfigCPU(config.cpu);
ConfigMemory(minimig_config.memory);
ConfigCPU(minimig_config.cpu);
ConfigChipset(config.chipset);
ConfigFloppy(config.floppy.drives, config.floppy.speed);
ConfigChipset(minimig_config.chipset);
ConfigFloppy(minimig_config.floppy.drives, minimig_config.floppy.speed);
if (config.memory & 0x40) UploadActionReplay();
if (minimig_config.memory & 0x40) UploadActionReplay();
if (reloadkickstart)
{
printf("Reloading kickstart ...\n");
rstval |= (SPI_RST_CPU | SPI_CPU_HLT);
spi_osd_cmd8(OSD_CMD_RST, rstval);
if (!UploadKickstart(config.kickstart))
if (!UploadKickstart(minimig_config.kickstart))
{
strcpy(config.kickstart, "Amiga/KICK.ROM");
if (!UploadKickstart(config.kickstart))
strcpy(minimig_config.kickstart, "Amiga/KICK.ROM");
if (!UploadKickstart(minimig_config.kickstart))
{
strcpy(config.kickstart, "KICK.ROM");
if (!UploadKickstart(config.kickstart))
strcpy(minimig_config.kickstart, "KICK.ROM");
if (!UploadKickstart(minimig_config.kickstart))
{
BootPrintEx("No Kickstart loaded. Press F12 for settings.");
BootPrintEx("** Halted! **");
@@ -368,18 +338,18 @@ static void ApplyConfiguration(char reloadkickstart)
rstval = 0;
spi_osd_cmd8(OSD_CMD_RST, rstval);
ConfigVideo(config.filter.hires, config.filter.lores, config.scanlines);
ConfigAudio(config.audio);
ConfigAutofire(config.autofire, 0xC);
ConfigVideo(minimig_config.filter.hires, minimig_config.filter.lores, minimig_config.scanlines);
ConfigAudio(minimig_config.audio);
ConfigAutofire(minimig_config.autofire, 0xC);
}
unsigned char LoadConfiguration(int num)
int minimig_LoadCfg(int num)
{
static const char config_id[] = "MNMGCFG0";
char updatekickstart = 0;
char result = 0;
int result = 0;
const char *filename = GetConfigurationName(num);
const char *filename = GetConfigurationName(num, 1);
// load configuration data
int size;
@@ -387,21 +357,21 @@ unsigned char LoadConfiguration(int num)
{
BootPrint("Opened configuration file\n");
printf("Configuration file size: %s, %d\n", filename, size);
if (size == sizeof(config))
if (size == sizeof(minimig_config) || size == 5152)
{
static configTYPE tmpconf;
static mm_configTYPE tmpconf = {};
if (FileLoadConfig(filename, &tmpconf, sizeof(tmpconf)))
{
// check file id and version
if (strncmp(tmpconf.id, config_id, sizeof(config.id)) == 0) {
if (strncmp(tmpconf.id, config_id, sizeof(minimig_config.id)) == 0) {
// A few more sanity checks...
if (tmpconf.floppy.drives <= 4) {
// If either the old config and new config have a different kickstart file,
// or this is the first boot, we need to upload a kickstart image.
if (strcmp(tmpconf.kickstart, config.kickstart) != 0) {
if (strcmp(tmpconf.kickstart, minimig_config.kickstart) != 0) {
updatekickstart = true;
}
memcpy((void*)&config, (void*)&tmpconf, sizeof(config));
memcpy((void*)&minimig_config, (void*)&tmpconf, sizeof(minimig_config));
result = 1; // We successfully loaded the config.
}
else BootPrint("Config file sanity check failed!\n");
@@ -417,19 +387,19 @@ unsigned char LoadConfiguration(int num)
if (FileLoadConfig(filename, &tmpconf, sizeof(tmpconf)))
{
// check file id and version
if (strncmp(tmpconf.id, config_id, sizeof(config.id)) == 0) {
if (strncmp(tmpconf.id, config_id, sizeof(minimig_config.id)) == 0) {
// A few more sanity checks...
if (tmpconf.floppy.drives <= 4) {
// If either the old config and new config have a different kickstart file,
// or this is the first boot, we need to upload a kickstart image.
if (strcmp(tmpconf.kickstart, config.kickstart) != 0) {
if (strcmp(tmpconf.kickstart, minimig_config.kickstart) != 0) {
updatekickstart = true;
}
memcpy((void*)&config, (void*)&tmpconf, sizeof(config));
config.cpu = tmpconf.cpu;
config.autofire = tmpconf.autofire;
memset(&config.hardfile[2], 0, sizeof(config.hardfile[2]));
memset(&config.hardfile[3], 0, sizeof(config.hardfile[3]));
memcpy((void*)&minimig_config, (void*)&tmpconf, sizeof(minimig_config));
minimig_config.cpu = tmpconf.cpu;
minimig_config.autofire = tmpconf.autofire;
memset(&minimig_config.hardfile[2], 0, sizeof(minimig_config.hardfile[2]));
memset(&minimig_config.hardfile[3], 0, sizeof(minimig_config.hardfile[3]));
result = 1; // We successfully loaded the config.
}
else BootPrint("Config file sanity check failed!\n");
@@ -438,25 +408,25 @@ unsigned char LoadConfiguration(int num)
}
else printf("Cannot load configuration file\n");
}
else printf("Wrong configuration file size: %d (expected: %u)\n", size, sizeof(config));
else printf("Wrong configuration file size: %d (expected: %u)\n", size, sizeof(minimig_config));
}
if (!result) {
BootPrint("Can not open configuration file!\n");
BootPrint("Setting config defaults\n");
// set default configuration
memset((void*)&config, 0, sizeof(config)); // Finally found default config bug - params were reversed!
strncpy(config.id, config_id, sizeof(config.id));
strcpy(config.kickstart, "Amiga/KICK.ROM");
config.memory = 0x11;
config.cpu = 0;
config.chipset = 0;
config.floppy.speed = CONFIG_FLOPPY2X;
config.floppy.drives = 1;
config.enable_ide = 0;
config.hardfile[0].enabled = 1;
config.hardfile[0].filename[0] = 0;
config.hardfile[1].enabled = 1;
config.hardfile[1].filename[0] = 0;
memset((void*)&minimig_config, 0, sizeof(minimig_config)); // Finally found default config bug - params were reversed!
strncpy(minimig_config.id, config_id, sizeof(minimig_config.id));
strcpy(minimig_config.kickstart, "Amiga/KICK.ROM");
minimig_config.memory = 0x11;
minimig_config.cpu = 0;
minimig_config.chipset = 0;
minimig_config.floppy.speed = CONFIG_FLOPPY2X;
minimig_config.floppy.drives = 1;
minimig_config.enable_ide = 0;
minimig_config.hardfile[0].enabled = 1;
minimig_config.hardfile[0].filename[0] = 0;
minimig_config.hardfile[1].enabled = 1;
minimig_config.hardfile[1].filename[0] = 0;
updatekickstart = true;
BootPrintEx(">>> No config found. Using defaults. <<<");
}
@@ -470,8 +440,8 @@ unsigned char LoadConfiguration(int num)
// print config to boot screen
char cfg_str[256];
sprintf(cfg_str, "CPU: %s, Chipset: %s, ChipRAM: %s, FastRAM: %s, SlowRAM: %s",
config_cpu_msg[config.cpu & 0x03], config_chipset_msg[(config.chipset >> 2) & 7],
config_memory_chip_msg[(config.memory >> 0) & 0x03], config_memory_fast_msg[(config.memory >> 4) & 0x03], config_memory_slow_msg[(config.memory >> 2) & 0x03]
config_cpu_msg[minimig_config.cpu & 0x03], config_chipset_msg[(minimig_config.chipset >> 2) & 7],
config_memory_chip_msg[(minimig_config.memory >> 0) & 0x03], config_memory_fast_msg[(minimig_config.memory >> 4) & 0x03], config_memory_slow_msg[(minimig_config.memory >> 2) & 0x03]
);
BootPrintEx(cfg_str);
@@ -480,13 +450,13 @@ unsigned char LoadConfiguration(int num)
{
BootPrintEx("Forcing NTSC video ...");
//force NTSC mode if F1 pressed
config.chipset |= CONFIG_NTSC;
minimig_config.chipset |= CONFIG_NTSC;
}
else if (is_key_pressed(60))
{
BootPrintEx("Forcing PAL video ...");
// force PAL mode if F2 pressed
config.chipset &= ~CONFIG_NTSC;
minimig_config.chipset &= ~CONFIG_NTSC;
}
ApplyConfiguration(updatekickstart);
@@ -502,8 +472,8 @@ void MinimigReset()
void SetKickstart(char *name)
{
uint len = strlen(name);
if (len > (sizeof(config.kickstart) - 1)) len = sizeof(config.kickstart) - 1;
memcpy(config.kickstart, name, len);
config.kickstart[len] = 0;
if (len > (sizeof(minimig_config.kickstart) - 1)) len = sizeof(minimig_config.kickstart) - 1;
memcpy(minimig_config.kickstart, name, len);
minimig_config.kickstart[len] = 0;
force_reload_kickstart = 1;
}

45
support/minimig/minimig_config.h
View File

@@ -8,44 +8,45 @@ typedef struct
{
unsigned char lores;
unsigned char hires;
} filterTYPE;
} mm_filterTYPE;
typedef struct
{
unsigned char speed;
unsigned char drives;
} floppyTYPE;
} mm_floppyTYPE;
typedef struct
{
unsigned char enabled;
unsigned char reserved;
char filename[1024];
} hardfileTYPE;
} mm_hardfileTYPE;
typedef struct
{
char id[8];
unsigned long version;
char kickstart[1024];
filterTYPE filter;
unsigned char memory;
unsigned char chipset;
floppyTYPE floppy;
unsigned char disable_ar3;
unsigned char enable_ide;
unsigned char scanlines;
unsigned char audio;
hardfileTYPE hardfile[4];
unsigned char cpu;
unsigned char autofire;
} configTYPE;
char id[8];
unsigned long version;
char kickstart[1024];
mm_filterTYPE filter;
unsigned char memory;
unsigned char chipset;
mm_floppyTYPE floppy;
unsigned char disable_ar3;
unsigned char enable_ide;
unsigned char scanlines;
unsigned char audio;
mm_hardfileTYPE hardfile[4];
unsigned char cpu;
unsigned char autofire;
char info[64];
} mm_configTYPE;
extern configTYPE config;
extern mm_configTYPE minimig_config;
unsigned char LoadConfiguration(int num);
unsigned char SaveConfiguration(int num);
const char* GetConfigDisplayName(int num);
int minimig_LoadCfg(int num);
int minimig_SaveCfg(int num);
const char* minimig_GetCfgInfo(int num);
void MinimigReset();
void SetKickstart(char *name);

12
support/minimig/minimig_hdd.cpp
View File

@@ -309,9 +309,9 @@ static void IdentifyDevice(uint16_t *pBuffer, hdfTYPE *hdf)
memcpy((char*)&pBuffer[23], ".100 ", 8); // firmware version - byte swapped
memcpy(p, "MiSTer ", 40); // model name - byte swapped
p += 8;
char *s = strrchr(config.hardfile[hdf->unit].filename, '/');
char *s = strrchr(minimig_config.hardfile[hdf->unit].filename, '/');
if (s) s++;
else s = config.hardfile[hdf->unit].filename;
else s = minimig_config.hardfile[hdf->unit].filename;
i = strlen(s);
if (i > 32) s += i - 32;
@@ -720,16 +720,16 @@ uint8_t OpenHardfile(uint8_t unit)
hdfTYPE *hdf = &HDF[unit];
hdf->unit = unit;
hdf->enabled = 0;
if (config.enable_ide && config.hardfile[unit].enabled)
if (minimig_config.enable_ide && minimig_config.hardfile[unit].enabled)
{
printf("\nChecking HDD %d\n", unit);
if (config.hardfile[unit].filename[0])
if (minimig_config.hardfile[unit].filename[0])
{
if (FileOpenEx(&hdf->file, config.hardfile[unit].filename, FileCanWrite(config.hardfile[unit].filename) ? O_RDWR : O_RDONLY))
if (FileOpenEx(&hdf->file, minimig_config.hardfile[unit].filename, FileCanWrite(minimig_config.hardfile[unit].filename) ? O_RDWR : O_RDONLY))
{
hdf->enabled = 1;
printf("file: \"%s\": ", hdf->file.name);
SetHardfileGeometry(hdf, !strcasecmp(".hdf", config.hardfile[unit].filename + strlen(config.hardfile[unit].filename) - 4));
SetHardfileGeometry(hdf, !strcasecmp(".hdf", minimig_config.hardfile[unit].filename + strlen(minimig_config.hardfile[unit].filename) - 4));
printf("size: %llu (%llu MB)\n", hdf->file.size, hdf->file.size >> 20);
printf("CHS: %u/%u/%u", hdf->cylinders, hdf->heads, hdf->sectors);
printf(" (%llu MB), ", ((((uint64_t)hdf->cylinders) * hdf->heads * hdf->sectors) >> 11));

2
user_io.cpp
View File

@@ -2373,8 +2373,6 @@ LCTRL LSHIFT LALT LGUI RCTRL RSHIFT RALT RGUI
#define EMU_BTN3 (2+(keyrah*4)) // left alt
#define EMU_BTN4 (3+(keyrah*4)) // left gui (usually windows key)
extern configTYPE config;
void user_io_check_reset(unsigned short modifiers, char useKeys)
{
unsigned short combo[] =