dave.c

Go to the documentation of this file.

/* Xep128: Minimalistic Enterprise-128 emulator with focus on "exotic" hardware
   Copyright (C)2015,2016 LGB (Gábor Lénárt) <lgblgblgb@gmail.com>
   http://xep128.lgb.hu/
 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 
#include "xep128.h"
#include "dave.h"
#include "primoemu.h"
#include "cpu.h"
#include "printer.h"
 
#include <SDL.h>
 
 
Uint8 dave_int_read;
Uint8 kbd_matrix[16]; // the "real" EP kbd matrix only uses the first 10 bytes though
static Uint8 dave_int_write;
static int cnt_1hz, cnt_50hz, cnt_31khz, cnt_1khz, cnt_tg0, cnt_tg1, cnt_tg2;
static int cnt_load_tg0, cnt_load_tg1, cnt_load_tg2;
static int tg0_ff, tg1_ff, tg2_ff;
int kbd_selector;
int cpu_cycles_per_dave_tick;
int mem_wait_states;
 
 
int audio_source = AUDIO_SOURCE_DAVE;
 
 
static SDL_AudioDeviceID audio = 0;
static SDL_AudioSpec audio_spec;
#define AUDIO_BUFFER_SIZE 0x4000
static Uint8 audio_buffer[AUDIO_BUFFER_SIZE];
static Uint8 *audio_buffer_r = audio_buffer;
static Uint8 *audio_buffer_w = audio_buffer;
static int dave_ticks_per_sample_counter = 0;
static int dave_ticks_per_sample = 6;
 
 
 
static inline Uint16 dave_render_audio_sample ( void )
{
        int left, right;
        /* TODO: missing noise channel, polynom counters/ops, modulation, etc */
        if (ports[0xA7] &  8)
                left  = ports[0xA8] << 2;               // left ch is in D/A mode
        else {                                          // left ch is in "normal" mode
                //tg0_ff = tg1_ff = tg2_ff = 1;
                left  = tg0_ff * ports[0xA8] +
                        tg1_ff * ports[0xA9] +
                        tg2_ff * ports[0xAA];
        }
        if (ports[0xA7] & 16)
                right = ports[0xAC] << 2;               // right ch is in D/A mode
        else {                                          // right ch is in "normal" mode
                //tg0_ff = tg1_ff = tg2_ff = 1;
                right = tg0_ff * ports[0xAC] +
                        tg1_ff * ports[0xAD] +
                        tg2_ff * ports[0xAE];
        }
#if 0
        DEBUGPRINT("DAVE: TG: %d %d %d Vol-l=%02X,%02X,%02X,%02X Vol-r=%02X,%02X,%02X,%02X FREQ=%d,%d,%d CNT=%d,%d,%d SYNC=%d" NL, tg0_ff, tg1_ff, tg2_ff,
                ports[0xA8], ports[0xA9], ports[0xAA], ports[0xAB],
                ports[0xAC], ports[0xAD], ports[0xAE], ports[0xAF],
                ports[0xA0] | ((ports[0xA1] & 15) << 8),
                ports[0xA2] | ((ports[0xA3] & 15) << 8),
                ports[0xA4] | ((ports[0xA5] & 15) << 8),
                cnt_tg0, cnt_tg1, cnt_tg2,
                ports[0xA7] & 7
        );
#endif
        return (right << 8) | left;
}
 
 
 
static void audio_fill_stereo ( Uint16 stereo_sample )
{
        *(Uint16*)(audio_buffer_w) = stereo_sample;
        audio_buffer_w += 2;
        if (audio_buffer_w == audio_buffer + AUDIO_BUFFER_SIZE)
                audio_buffer_w = audio_buffer;
}
 
 
 
static void audio_callback(void *userdata, Uint8 *stream, int len)
{
        while (len--) {
                if (audio_buffer_r == audio_buffer_w) {
                        //*(stream++) = 0;
                        *(stream++) = 0;
                } else {
                        //*(stream++) = *(audio_buffer_r++);
                        *(stream++) = *(audio_buffer_r++);
                        if (audio_buffer_r == audio_buffer + AUDIO_BUFFER_SIZE)
                                audio_buffer_r = audio_buffer;
                }
        }
}
 
 
 
void audio_start ( void )
{
        if (audio)
                SDL_PauseAudioDevice(audio, 0);
}
 
 
 
void audio_stop ( void )
{
        if (audio)
                SDL_PauseAudioDevice(audio, 1);
}
 
 
 
void audio_close ( void )
{
        audio_stop();
        if (audio)
                SDL_CloseAudioDevice(audio);
        audio = 0;
}
 
 
 
void audio_init ( int enable )
{
        SDL_AudioSpec want;
        if (!enable) return;
        SDL_memset(&want, 0, sizeof(want));
        want.freq = 41666;
        want.format = AUDIO_U8;
        want.channels = 2;
        want.samples = 4096;
        want.callback = audio_callback;
        want.userdata = NULL;
        audio = SDL_OpenAudioDevice(NULL, 0, &want, &audio_spec, 0);
        if (!audio)
                ERROR_WINDOW("Cannot initiailze audio: %s\n", SDL_GetError());
        else if (want.freq != audio_spec.freq || want.format != audio_spec.format || want.channels != audio_spec.channels) {
                audio_close();
                ERROR_WINDOW("Bad audio parameters (w/h freq=%d/%d, fmt=%d/%d, chans=%d/%d, smpls=%d/%d, cannot use sound",
                        want.freq, audio_spec.freq, want.format, audio_spec.format, want.channels, audio_spec.channels, want.samples, audio_spec.samples
                );
        } else
                audio_stop();   // still stopped ... must be audio_start()'ed by the caller
}
 
 
 
void dave_set_clock ( void )
{
        // FIXME maybe: Currently, it's assumed that Dave and CPU has fixed relation about clock
        //double turbo_rate = (double)CPU_CLOCK / (double)DEFAULT_CPU_CLOCK;
        if (ports[0xBF] & 2) {
                cpu_cycles_per_dave_tick = 24; // 12MHz (??)
                dave_ticks_per_sample = 4;
        } else {
                cpu_cycles_per_dave_tick = 16; // 8MHz  (??)
                dave_ticks_per_sample = 6;
        }
        //DEBUG("DAVE: CLOCK: assumming %dMHz input, CPU clock divisor is %d, CPU cycles per Dave tick is %d" NL, (ports[0xBF] & 2) ? 12 : 8, CPU_CLOCK / cpu_cycles_per_dave_tick, cpu_cycles_per_dave_tick);
        mem_wait_states = (CPU_CLOCK > 4000000) ? 2 : 1; // memory wait states (non-VRAM only!) asked by BF port is 1, but 2 for "turbo" Z80 solutions
}
 
 
 
void kbd_matrix_reset ( void )
{
        memset(kbd_matrix, 0xFF, sizeof(kbd_matrix));
}
 
 
 
void dave_reset ( void )
{
        int a;
        //kbd_matrix_reset();
        for (a = 0xA0; a <= 0xBF; a++)
                z80ex_pwrite_cb(a, 0);
        dave_int_read = 0;
        dave_int_write = 0;
        kbd_selector = -1;
        cnt_1hz = 0; cnt_50hz = 0; cnt_31khz = 0; cnt_1khz = 0; cnt_tg0 = 0; cnt_tg1 = 0; cnt_tg2 = 0;
        tg0_ff = 0; tg1_ff = 0; tg2_ff = 0;
        //mem_ws_all = 0;
        //mem_ws_m1  = 0;
        //NICK_SLOTS_PER_DAVE_TICK_HI = NICK_SLOTS_PER_SEC / 250000.0;
        //_set_timing();
        DEBUG("DAVE: reset" NL);
}
 
 
 
/* Called by Nick */
void dave_int1(int level)
{
        if (level) {
                dave_int_read |= 16; // set level
        } else {
                // the truth is here, if previous level was set (falling edge), and int1 is enabled, then set latch!
                if ((dave_int_read & 16) && (dave_int_write & 16)) {
                        DEBUG("DAVE/VINT: LACTH is set!" NL);
                        dave_int_read |= 32; // set latch
                        if (primo_on)
                                nmi_pending = primo_nmi_enabled;
                }
                dave_int_read &= 239; // reset level
        }
}
 
 
 
static inline void dave_int_tg ( void )
{
        if (dave_int_write & 1)
                dave_int_read |= 2;     // set latch if TG int is enabled
        dave_int_read ^= 1;             // negate level
}
 
 
 
void dave_tick ( void )
{
        // TODO 31.25KHz counter for some reason :) what I forgot :-P
        /* 50Hz counter */
        if ((--cnt_50hz) < 0) {
                cnt_50hz = 5000 - 1;
                if ((ports[0xA7] & 96) == 32)
                        dave_int_tg();
        }
        /* 1KHz counter */
        if ((--cnt_1khz) < 0) {
                cnt_1khz = 250 - 1;
                if ((ports[0xA7] & 96) ==  0)
                        dave_int_tg();
        }
        /* counter for tone channel #0 */
        if (ports[0xA7] & 1) { // sync mode?
                cnt_tg0 = cnt_load_tg0;
                tg0_ff = 0;
        } else if ((--cnt_tg0) < 0) {
                cnt_tg0 = cnt_load_tg0;
                tg0_ff ^= 1;
                if ((ports[0xA7] & 96) == 64)
                        dave_int_tg();
        }
        /* counter for tone channel #1 */
        if (ports[0xA7] & 2) { // sync mode?
                cnt_tg1 = cnt_load_tg1;
                tg1_ff = 0;
        } else if ((--cnt_tg1) < 0) {
                cnt_tg1 = cnt_load_tg1;
                tg1_ff ^= 1;
                if ((ports[0xA7] & 96) == 96)
                        dave_int_tg();
        }
        /* counter for tone channel #2 */
        if (ports[0xA7] & 4) { // sync mode?
                cnt_tg2 = cnt_load_tg2;
                tg2_ff = 0;
        } else if ((--cnt_tg2) < 0) {
                cnt_tg2 = cnt_load_tg2;
                tg2_ff ^= 1;
        }
        /* handling the 1Hz interrupt */
        if ((--cnt_1hz) < 0) {
                cnt_1hz = 250000 - 1;
                if (dave_int_write & 4)
                        dave_int_read |= 8; // set latch, if 1Hz int source is enabled
                dave_int_read ^= 4; // negate 1Hz interrupt level bit (actually the freq is 0.5Hz, but int is generated on each edge, thus 1Hz)
                //DEBUG("DAVE: 1HZ interrupt level: %d" NL, dave_int_read & 4);
        }
        // SOUND
        if (audio) {
                if ((--dave_ticks_per_sample_counter) < 0) {
                        switch (audio_source) {
                                case AUDIO_SOURCE_DAVE:
                                        audio_fill_stereo(dave_render_audio_sample());
                                        break;
                                case AUDIO_SOURCE_PRINTER_COVOX:
                                        audio_fill_stereo((printer_data_byte << 8) | printer_data_byte);        // both stereo channels has the same byte ...
                                        break;
                                case AUDIO_SOURCE_DTM_DAC4:
                                        audio_fill_stereo(
                                                ((ports[0xF0] + ports[0xF1]) >> 1) |    // left
                                                (((ports[0xF2] + ports[0xF3]) >> 1) << 8)       // right
                                        );
                                        break;
                                default:
                                        FATAL("Audio source renderer %d is not known!", audio_source);
                                        break;
                        }
                        dave_ticks_per_sample_counter = dave_ticks_per_sample - 1;
                }
        }
}
 
 
 
void dave_configure_interrupts ( Uint8 n )
{
        dave_int_write = n;
        dave_int_read &= (0x55 | ((~n) & 0xAA)); // this "nice" stuff resets desired latches
        dave_int_read &= (0x55 | ((n << 1) & 0xAA)); // TODO / FIXME: not sure if it is needed!
}
 
 
 
void dave_write_audio_register ( Uint8 port, Uint8 value )
{
        printer_disable_covox();        // disable COVOX mode, if any
        audio_source = AUDIO_SOURCE_DAVE;
        switch (port) {
                case 0xA0:
                        cnt_load_tg0 = (cnt_load_tg0 & 0xF00 ) | value;
                        break;
                case 0xA1:
                        cnt_load_tg0 = (cnt_load_tg0 & 0x0FF ) | ((value & 0xF) << 8);
                        break;
                case 0xA2:
                        cnt_load_tg1 = (cnt_load_tg1 & 0xF00 ) | value;
                        break;
                case 0xA3:
                        cnt_load_tg1 = (cnt_load_tg1 & 0x0FF ) | ((value & 0xF) << 8);
                        break;
                case 0xA4:
                        cnt_load_tg2 = (cnt_load_tg2 & 0xF00 ) | value;
                        break;
                case 0xA5:
                        cnt_load_tg2 = (cnt_load_tg2 & 0x0FF ) | ((value & 0xF) << 8);
                        break;
                case 0xA8:
                case 0xA9:
                case 0xAA:
                case 0xAB:
                case 0xAC:
                case 0xAD:
                case 0xAE:
                case 0xAF:
                        ports[port] &= 63;      // so we don't need to do this AND again and again ...
                        break;
        }
}