2016-03-30 20:07:55 +00:00
|
|
|
#include "gb.h"
|
2017-04-21 13:00:53 +00:00
|
|
|
#ifdef _WIN32
|
2018-03-29 18:27:19 +00:00
|
|
|
#ifndef _WIN32_WINNT
|
2017-04-21 13:00:53 +00:00
|
|
|
#define _WIN32_WINNT 0x0500
|
2018-03-29 18:27:19 +00:00
|
|
|
#endif
|
2019-08-16 14:38:43 +00:00
|
|
|
#include <windows.h>
|
2017-04-21 13:00:53 +00:00
|
|
|
#else
|
|
|
|
#include <sys/time.h>
|
|
|
|
#endif
|
|
|
|
|
2019-06-15 20:22:27 +00:00
|
|
|
static const unsigned GB_TAC_TRIGGER_BITS[] = {512, 8, 32, 128};
|
2018-02-23 11:16:05 +00:00
|
|
|
|
2020-04-25 12:12:10 +00:00
|
|
|
#ifndef GB_DISABLE_TIMEKEEPING
|
2017-04-21 13:00:53 +00:00
|
|
|
static int64_t get_nanoseconds(void)
|
|
|
|
{
|
|
|
|
#ifndef _WIN32
|
|
|
|
struct timeval now;
|
|
|
|
gettimeofday(&now, NULL);
|
|
|
|
return (now.tv_usec) * 1000 + now.tv_sec * 1000000000L;
|
|
|
|
#else
|
|
|
|
FILETIME time;
|
|
|
|
GetSystemTimeAsFileTime(&time);
|
|
|
|
return (((int64_t)time.dwHighDateTime << 32) | time.dwLowDateTime) * 100L;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nsleep(uint64_t nanoseconds)
|
|
|
|
{
|
|
|
|
#ifndef _WIN32
|
|
|
|
struct timespec sleep = {0, nanoseconds};
|
|
|
|
nanosleep(&sleep, NULL);
|
|
|
|
#else
|
|
|
|
HANDLE timer;
|
|
|
|
LARGE_INTEGER time;
|
|
|
|
timer = CreateWaitableTimer(NULL, true, NULL);
|
|
|
|
time.QuadPart = -(nanoseconds / 100L);
|
|
|
|
SetWaitableTimer(timer, &time, 0, NULL, NULL, false);
|
|
|
|
WaitForSingleObject(timer, INFINITE);
|
|
|
|
CloseHandle(timer);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GB_timing_sync_turbo(GB_gameboy_t *gb)
|
|
|
|
{
|
|
|
|
if (!gb->turbo_dont_skip) {
|
|
|
|
int64_t nanoseconds = get_nanoseconds();
|
2018-02-10 21:30:30 +00:00
|
|
|
if (nanoseconds <= gb->last_sync + (1000000000LL * LCDC_PERIOD / GB_get_clock_rate(gb))) {
|
2017-04-21 13:00:53 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
gb->last_sync = nanoseconds;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GB_timing_sync(GB_gameboy_t *gb)
|
|
|
|
{
|
2017-06-03 14:02:12 +00:00
|
|
|
if (gb->turbo) {
|
|
|
|
gb->cycles_since_last_sync = 0;
|
|
|
|
return;
|
|
|
|
}
|
2017-04-21 13:00:53 +00:00
|
|
|
/* Prevent syncing if not enough time has passed.*/
|
2019-06-19 19:44:54 +00:00
|
|
|
if (gb->cycles_since_last_sync < LCDC_PERIOD / 3) return;
|
2017-04-21 13:00:53 +00:00
|
|
|
|
2018-02-20 19:17:12 +00:00
|
|
|
uint64_t target_nanoseconds = gb->cycles_since_last_sync * 1000000000LL / 2 / GB_get_clock_rate(gb); /* / 2 because we use 8MHz units */
|
2017-04-21 13:00:53 +00:00
|
|
|
int64_t nanoseconds = get_nanoseconds();
|
2018-03-27 20:33:31 +00:00
|
|
|
int64_t time_to_sleep = target_nanoseconds + gb->last_sync - nanoseconds;
|
|
|
|
if (time_to_sleep > 0 && time_to_sleep < LCDC_PERIOD * 1000000000LL / GB_get_clock_rate(gb)) {
|
|
|
|
nsleep(time_to_sleep);
|
2017-04-21 13:00:53 +00:00
|
|
|
gb->last_sync += target_nanoseconds;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
gb->last_sync = nanoseconds;
|
|
|
|
}
|
|
|
|
|
|
|
|
gb->cycles_since_last_sync = 0;
|
2019-06-07 15:27:25 +00:00
|
|
|
if (gb->update_input_hint_callback) {
|
|
|
|
gb->update_input_hint_callback(gb);
|
|
|
|
}
|
2017-04-21 13:00:53 +00:00
|
|
|
}
|
2017-10-12 16:24:12 +00:00
|
|
|
#else
|
2016-03-30 20:07:55 +00:00
|
|
|
|
2017-10-12 16:24:12 +00:00
|
|
|
bool GB_timing_sync_turbo(GB_gameboy_t *gb)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GB_timing_sync(GB_gameboy_t *gb)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2020-11-20 22:52:54 +00:00
|
|
|
|
|
|
|
#define IR_DECAY 31500
|
|
|
|
#define IR_THRESHOLD 19900
|
|
|
|
#define IR_MAX IR_THRESHOLD * 2 + IR_DECAY
|
|
|
|
|
|
|
|
static void GB_ir_run(GB_gameboy_t *gb, uint32_t cycles)
|
2016-07-20 22:03:13 +00:00
|
|
|
{
|
2020-11-20 22:52:54 +00:00
|
|
|
if (gb->model == GB_MODEL_AGB) return;
|
|
|
|
if (gb->infrared_input || gb->cart_ir || (gb->io_registers[GB_IO_RP] & 1)) {
|
|
|
|
gb->ir_sensor += cycles;
|
|
|
|
if (gb->ir_sensor > IR_MAX) {
|
|
|
|
gb->ir_sensor = IR_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
gb->effective_ir_input = gb->ir_sensor >= IR_THRESHOLD && gb->ir_sensor <= IR_THRESHOLD + IR_DECAY;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (gb->ir_sensor <= cycles) {
|
|
|
|
gb->ir_sensor = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
gb->ir_sensor -= cycles;
|
|
|
|
}
|
|
|
|
gb->effective_ir_input = false;
|
2016-07-20 22:03:13 +00:00
|
|
|
}
|
2020-11-20 22:52:54 +00:00
|
|
|
|
2016-07-20 22:03:13 +00:00
|
|
|
}
|
|
|
|
|
2016-08-06 10:56:29 +00:00
|
|
|
static void advance_tima_state_machine(GB_gameboy_t *gb)
|
|
|
|
{
|
|
|
|
if (gb->tima_reload_state == GB_TIMA_RELOADED) {
|
|
|
|
gb->tima_reload_state = GB_TIMA_RUNNING;
|
|
|
|
}
|
|
|
|
else if (gb->tima_reload_state == GB_TIMA_RELOADING) {
|
2018-02-23 13:33:44 +00:00
|
|
|
gb->io_registers[GB_IO_IF] |= 4;
|
2016-08-06 10:56:29 +00:00
|
|
|
gb->tima_reload_state = GB_TIMA_RELOADED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-23 11:16:05 +00:00
|
|
|
static void increase_tima(GB_gameboy_t *gb)
|
|
|
|
{
|
|
|
|
gb->io_registers[GB_IO_TIMA]++;
|
|
|
|
if (gb->io_registers[GB_IO_TIMA] == 0) {
|
|
|
|
gb->io_registers[GB_IO_TIMA] = gb->io_registers[GB_IO_TMA];
|
|
|
|
gb->tima_reload_state = GB_TIMA_RELOADING;
|
|
|
|
}
|
|
|
|
}
|
2016-08-05 14:22:12 +00:00
|
|
|
|
2021-02-25 13:43:38 +00:00
|
|
|
static void GB_set_internal_div_counter(GB_gameboy_t *gb, uint16_t value)
|
2018-02-23 11:16:05 +00:00
|
|
|
{
|
|
|
|
/* TIMA increases when a specific high-bit becomes a low-bit. */
|
|
|
|
value &= INTERNAL_DIV_CYCLES - 1;
|
2021-02-25 13:43:38 +00:00
|
|
|
uint16_t triggers = gb->div_counter & ~value;
|
2018-12-31 20:06:20 +00:00
|
|
|
if ((gb->io_registers[GB_IO_TAC] & 4) && (triggers & GB_TAC_TRIGGER_BITS[gb->io_registers[GB_IO_TAC] & 3])) {
|
2018-02-23 11:16:05 +00:00
|
|
|
increase_tima(gb);
|
|
|
|
}
|
2018-06-09 12:11:20 +00:00
|
|
|
|
|
|
|
/* TODO: Can switching to double speed mode trigger an event? */
|
2021-02-25 13:43:38 +00:00
|
|
|
uint16_t apu_bit = gb->cgb_double_speed? 0x2000 : 0x1000;
|
|
|
|
if (triggers & apu_bit) {
|
2018-02-23 11:16:05 +00:00
|
|
|
GB_apu_run(gb);
|
|
|
|
GB_apu_div_event(gb);
|
2016-08-05 14:22:12 +00:00
|
|
|
}
|
2021-02-25 13:43:38 +00:00
|
|
|
else {
|
|
|
|
uint16_t secondary_triggers = ~gb->div_counter & value;
|
|
|
|
if (secondary_triggers & apu_bit) {
|
|
|
|
GB_apu_run(gb);
|
|
|
|
GB_apu_div_secondary_event(gb);
|
|
|
|
}
|
|
|
|
}
|
2018-02-23 11:16:05 +00:00
|
|
|
gb->div_counter = value;
|
|
|
|
}
|
2016-04-09 13:48:37 +00:00
|
|
|
|
2018-02-23 11:16:05 +00:00
|
|
|
static void GB_timers_run(GB_gameboy_t *gb, uint8_t cycles)
|
|
|
|
{
|
2020-02-15 17:21:43 +00:00
|
|
|
if (gb->stopped) {
|
2020-12-25 18:40:39 +00:00
|
|
|
if (GB_is_cgb(gb)) {
|
|
|
|
gb->apu.apu_cycles += 4 << !gb->cgb_double_speed;
|
|
|
|
}
|
2020-02-15 17:21:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-24 22:48:45 +00:00
|
|
|
GB_STATE_MACHINE(gb, div, cycles, 1) {
|
2018-02-23 11:16:05 +00:00
|
|
|
GB_STATE(gb, div, 1);
|
2018-02-23 13:33:44 +00:00
|
|
|
GB_STATE(gb, div, 2);
|
2018-09-14 21:47:26 +00:00
|
|
|
GB_STATE(gb, div, 3);
|
2018-02-23 11:16:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GB_set_internal_div_counter(gb, 0);
|
2018-09-14 21:47:26 +00:00
|
|
|
main:
|
2018-03-31 12:52:31 +00:00
|
|
|
GB_SLEEP(gb, div, 1, 3);
|
2018-02-23 11:16:05 +00:00
|
|
|
while (true) {
|
2016-08-06 10:56:29 +00:00
|
|
|
advance_tima_state_machine(gb);
|
2018-02-23 11:16:05 +00:00
|
|
|
GB_set_internal_div_counter(gb, gb->div_counter + 4);
|
|
|
|
gb->apu.apu_cycles += 4 << !gb->cgb_double_speed;
|
2018-02-23 13:33:44 +00:00
|
|
|
GB_SLEEP(gb, div, 2, 4);
|
2016-08-06 10:56:29 +00:00
|
|
|
}
|
2018-09-14 21:47:26 +00:00
|
|
|
|
|
|
|
/* Todo: This is ugly to allow compatibility with 0.11 save states. Fix me when breaking save compatibility */
|
|
|
|
{
|
|
|
|
div3:
|
|
|
|
/* Compensate for lack of prefetch emulation, as well as DIV's internal initial value */
|
|
|
|
GB_set_internal_div_counter(gb, 8);
|
|
|
|
goto main;
|
|
|
|
}
|
2018-02-23 11:16:05 +00:00
|
|
|
}
|
|
|
|
|
2019-03-15 12:36:10 +00:00
|
|
|
static void advance_serial(GB_gameboy_t *gb, uint8_t cycles)
|
|
|
|
{
|
2021-02-26 14:40:35 +00:00
|
|
|
if (gb->printer.command_state || gb->printer.bits_received) {
|
|
|
|
gb->printer.idle_time += cycles;
|
|
|
|
}
|
2019-03-15 12:36:10 +00:00
|
|
|
if (gb->serial_length == 0) {
|
|
|
|
gb->serial_cycles += cycles;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (cycles > gb->serial_length) {
|
|
|
|
advance_serial(gb, gb->serial_length);
|
|
|
|
cycles -= gb->serial_length;
|
|
|
|
}
|
|
|
|
|
2017-06-23 14:58:04 +00:00
|
|
|
uint16_t previous_serial_cycles = gb->serial_cycles;
|
|
|
|
gb->serial_cycles += cycles;
|
2019-03-15 12:36:10 +00:00
|
|
|
if ((gb->serial_cycles & gb->serial_length) != (previous_serial_cycles & gb->serial_length)) {
|
|
|
|
gb->serial_count++;
|
|
|
|
if (gb->serial_count == 8) {
|
2017-06-23 14:58:04 +00:00
|
|
|
gb->serial_length = 0;
|
2019-03-15 12:36:10 +00:00
|
|
|
gb->serial_count = 0;
|
2016-09-05 19:13:28 +00:00
|
|
|
gb->io_registers[GB_IO_SC] &= ~0x80;
|
|
|
|
gb->io_registers[GB_IO_IF] |= 8;
|
|
|
|
}
|
2019-03-15 12:36:10 +00:00
|
|
|
|
|
|
|
gb->io_registers[GB_IO_SB] <<= 1;
|
|
|
|
|
|
|
|
if (gb->serial_transfer_bit_end_callback) {
|
|
|
|
gb->io_registers[GB_IO_SB] |= gb->serial_transfer_bit_end_callback(gb);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
gb->io_registers[GB_IO_SB] |= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gb->serial_length) {
|
|
|
|
/* Still more bits to send */
|
|
|
|
if (gb->serial_transfer_bit_start_callback) {
|
|
|
|
gb->serial_transfer_bit_start_callback(gb, gb->io_registers[GB_IO_SB] & 0x80);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-05 19:13:28 +00:00
|
|
|
}
|
2019-03-15 12:36:10 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2021-02-25 20:12:14 +00:00
|
|
|
static void GB_rtc_run(GB_gameboy_t *gb, uint8_t cycles)
|
|
|
|
{
|
|
|
|
if (gb->cartridge_type->mbc_type != GB_HUC3 && !gb->cartridge_type->has_rtc) return;
|
|
|
|
gb->rtc_cycles += cycles;
|
|
|
|
time_t current_time = 0;
|
|
|
|
|
|
|
|
switch (gb->rtc_mode) {
|
|
|
|
case GB_RTC_MODE_SYNC_TO_HOST:
|
|
|
|
// Sync in a 1/32s resolution
|
|
|
|
if (gb->rtc_cycles < GB_get_unmultiplied_clock_rate(gb) / 16) return;
|
|
|
|
gb->rtc_cycles -= GB_get_unmultiplied_clock_rate(gb) / 16;
|
|
|
|
current_time = time(NULL);
|
|
|
|
break;
|
|
|
|
case GB_RTC_MODE_ACCURATE:
|
2021-02-25 22:40:18 +00:00
|
|
|
if (gb->cartridge_type->mbc_type != GB_HUC3 && (gb->rtc_real.high & 0x40)) {
|
|
|
|
gb->rtc_cycles -= cycles;
|
|
|
|
return;
|
|
|
|
}
|
2021-02-25 20:12:14 +00:00
|
|
|
if (gb->rtc_cycles < GB_get_unmultiplied_clock_rate(gb) * 2) return;
|
|
|
|
gb->rtc_cycles -= GB_get_unmultiplied_clock_rate(gb) * 2;
|
|
|
|
current_time = gb->last_rtc_second + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gb->cartridge_type->mbc_type == GB_HUC3) {
|
|
|
|
while (gb->last_rtc_second / 60 < current_time / 60) {
|
|
|
|
gb->last_rtc_second += 60;
|
|
|
|
gb->huc3_minutes++;
|
|
|
|
if (gb->huc3_minutes == 60 * 24) {
|
|
|
|
gb->huc3_days++;
|
|
|
|
gb->huc3_minutes = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((gb->rtc_real.high & 0x40) == 0) { /* is timer running? */
|
|
|
|
while (gb->last_rtc_second + 60 * 60 * 24 < current_time) {
|
|
|
|
gb->last_rtc_second += 60 * 60 * 24;
|
|
|
|
if (++gb->rtc_real.days == 0) {
|
|
|
|
if (gb->rtc_real.high & 1) { /* Bit 8 of days*/
|
|
|
|
gb->rtc_real.high |= 0x80; /* Overflow bit */
|
|
|
|
}
|
|
|
|
gb->rtc_real.high ^= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (gb->last_rtc_second < current_time) {
|
|
|
|
gb->last_rtc_second++;
|
|
|
|
if (++gb->rtc_real.seconds != 60) continue;
|
|
|
|
gb->rtc_real.seconds = 0;
|
|
|
|
|
|
|
|
if (++gb->rtc_real.minutes != 60) continue;
|
|
|
|
gb->rtc_real.minutes = 0;
|
|
|
|
|
|
|
|
if (++gb->rtc_real.hours != 24) continue;
|
|
|
|
gb->rtc_real.hours = 0;
|
|
|
|
|
|
|
|
if (++gb->rtc_real.days != 0) continue;
|
|
|
|
|
|
|
|
if (gb->rtc_real.high & 1) { /* Bit 8 of days*/
|
|
|
|
gb->rtc_real.high |= 0x80; /* Overflow bit */
|
|
|
|
}
|
2021-02-25 22:40:18 +00:00
|
|
|
|
|
|
|
gb->rtc_real.high ^= 1;
|
2021-02-25 20:12:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-15 12:36:10 +00:00
|
|
|
void GB_advance_cycles(GB_gameboy_t *gb, uint8_t cycles)
|
2020-05-09 21:37:52 +00:00
|
|
|
{
|
|
|
|
gb->apu.pcm_mask[0] = gb->apu.pcm_mask[1] = 0xFF; // Sort of hacky, but too many cross-component interactions to do it right
|
2019-03-15 12:36:10 +00:00
|
|
|
// Affected by speed boost
|
|
|
|
gb->dma_cycles += cycles;
|
|
|
|
|
2020-02-15 17:21:43 +00:00
|
|
|
GB_timers_run(gb, cycles);
|
2019-06-07 10:53:50 +00:00
|
|
|
if (!gb->stopped) {
|
|
|
|
advance_serial(gb, cycles); // TODO: Verify what happens in STOP mode
|
|
|
|
}
|
2016-09-05 19:13:28 +00:00
|
|
|
|
2016-09-16 08:58:31 +00:00
|
|
|
gb->debugger_ticks += cycles;
|
|
|
|
|
2018-03-05 19:17:37 +00:00
|
|
|
if (!gb->cgb_double_speed) {
|
|
|
|
cycles <<= 1;
|
|
|
|
}
|
2019-01-12 23:09:41 +00:00
|
|
|
|
2016-03-30 20:07:55 +00:00
|
|
|
// Not affected by speed boost
|
2020-12-25 18:40:39 +00:00
|
|
|
if (gb->io_registers[GB_IO_LCDC] & 0x80) {
|
|
|
|
gb->double_speed_alignment += cycles;
|
|
|
|
}
|
2016-03-30 20:07:55 +00:00
|
|
|
gb->hdma_cycles += cycles;
|
2017-07-21 20:06:02 +00:00
|
|
|
gb->apu_output.sample_cycles += cycles;
|
2017-04-21 13:00:53 +00:00
|
|
|
gb->cycles_since_last_sync += cycles;
|
2018-01-31 13:18:04 +00:00
|
|
|
gb->cycles_since_run += cycles;
|
2019-10-19 16:26:04 +00:00
|
|
|
|
|
|
|
if (gb->rumble_state) {
|
|
|
|
gb->rumble_on_cycles++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
gb->rumble_off_cycles++;
|
|
|
|
}
|
|
|
|
|
2019-06-07 10:53:50 +00:00
|
|
|
if (!gb->stopped) { // TODO: Verify what happens in STOP mode
|
|
|
|
GB_dma_run(gb);
|
|
|
|
GB_hdma_run(gb);
|
|
|
|
}
|
2017-07-27 20:11:33 +00:00
|
|
|
GB_apu_run(gb);
|
2017-02-19 00:22:50 +00:00
|
|
|
GB_display_run(gb, cycles);
|
2020-11-20 22:52:54 +00:00
|
|
|
GB_ir_run(gb, cycles);
|
2021-02-25 20:12:14 +00:00
|
|
|
GB_rtc_run(gb, cycles);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 14:22:12 +00:00
|
|
|
/*
|
|
|
|
This glitch is based on the expected results of mooneye-gb rapid_toggle test.
|
|
|
|
This glitch happens because how TIMA is increased, see GB_set_internal_div_counter.
|
|
|
|
According to GiiBiiAdvance, GBC's behavior is different, but this was not tested or implemented.
|
|
|
|
*/
|
|
|
|
void GB_emulate_timer_glitch(GB_gameboy_t *gb, uint8_t old_tac, uint8_t new_tac)
|
|
|
|
{
|
|
|
|
/* Glitch only happens when old_tac is enabled. */
|
|
|
|
if (!(old_tac & 4)) return;
|
|
|
|
|
2019-06-15 20:22:27 +00:00
|
|
|
unsigned old_clocks = GB_TAC_TRIGGER_BITS[old_tac & 3];
|
|
|
|
unsigned new_clocks = GB_TAC_TRIGGER_BITS[new_tac & 3];
|
2016-08-05 14:22:12 +00:00
|
|
|
|
|
|
|
/* The bit used for overflow testing must have been 1 */
|
2018-12-31 20:06:20 +00:00
|
|
|
if (gb->div_counter & old_clocks) {
|
2016-08-05 14:22:12 +00:00
|
|
|
/* And now either the timer must be disabled, or the new bit used for overflow testing be 0. */
|
2018-12-31 20:06:20 +00:00
|
|
|
if (!(new_tac & 4) || gb->div_counter & new_clocks) {
|
2016-08-05 14:22:12 +00:00
|
|
|
increase_tima(gb);
|
2016-03-30 20:07:55 +00:00
|
|
|
}
|
|
|
|
}
|
2016-07-17 21:39:43 +00:00
|
|
|
}
|