475 lines
17 KiB
TypeScript
475 lines
17 KiB
TypeScript
/*
|
|
* pokey.c - POKEY sound chip emulation
|
|
*
|
|
* Copyright (C) 1995-1998 David Firth
|
|
* Copyright (C) 1998-2008 Atari800 development team (see DOC/CREDITS)
|
|
*
|
|
* This file is part of the Atari800 emulator project which emulates
|
|
* the Atari 400, 800, 800XL, 130XE, and 5200 8-bit computers.
|
|
*
|
|
* Atari800 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.
|
|
*
|
|
* Atari800 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 Atari800; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
import { dumpRAM } from "../../common/emu"
|
|
import { hex, lpad, safe_extend } from "../../common/util"
|
|
|
|
const AUDF1 = 0x00
|
|
const AUDC1 = 0x01
|
|
const AUDF2 = 0x02
|
|
const AUDC2 = 0x03
|
|
const AUDF3 = 0x04
|
|
const AUDC3 = 0x05
|
|
const AUDF4 = 0x06
|
|
const AUDC4 = 0x07
|
|
const AUDCTL = 0x08
|
|
const STIMER = 0x09
|
|
const SKRES = 0x0a
|
|
const POTGO = 0x0b
|
|
const SEROUT = 0x0d
|
|
const IRQEN = 0x0e
|
|
const SKCTL = 0x0f
|
|
|
|
const POT0 = 0x00
|
|
const POT1 = 0x01
|
|
const POT2 = 0x02
|
|
const POT3 = 0x03
|
|
const POT4 = 0x04
|
|
const POT5 = 0x05
|
|
const POT6 = 0x06
|
|
const POT7 = 0x07
|
|
const ALLPOT = 0x08
|
|
const KBCODE = 0x09
|
|
const RANDOM = 0x0a
|
|
const SERIN = 0x0d
|
|
const IRQST = 0x0e
|
|
const SKSTAT = 0x0f
|
|
|
|
/* definitions for AUDCx (D201, D203, D205, D207) */
|
|
const NOTPOLY5 = 0x80 /* selects POLY5 or direct CLOCK */
|
|
const POLY4 = 0x40 /* selects POLY4 or POLY17 */
|
|
const PURETONE = 0x20 /* selects POLY4/17 or PURE tone */
|
|
const VOL_ONLY = 0x10 /* selects VOLUME OUTPUT ONLY */
|
|
const VOLUME_MASK = 0x0f /* volume mask */
|
|
|
|
/* definitions for AUDCTL (D208) */
|
|
const POLY9 = 0x80 /* selects POLY9 or POLY17 */
|
|
const CH1_179 = 0x40 /* selects 1.78979 MHz for Ch 1 */
|
|
const CH3_179 = 0x20 /* selects 1.78979 MHz for Ch 3 */
|
|
const CH1_CH2 = 0x10 /* clocks channel 1 w/channel 2 */
|
|
const CH3_CH4 = 0x08 /* clocks channel 3 w/channel 4 */
|
|
const CH1_FILTER = 0x04 /* selects channel 1 high pass filter */
|
|
const CH2_FILTER = 0x02 /* selects channel 2 high pass filter */
|
|
const CLOCK_15 = 0x01 /* selects 15.6999kHz or 63.9210kHz */
|
|
|
|
/* for accuracy, the 64kHz and 15kHz clocks are exact divisions of
|
|
the 1.79MHz clock */
|
|
const DIV_64 = 28 /* divisor for 1.79MHz clock to 64 kHz */
|
|
const DIV_15 = 114 /* divisor for 1.79MHz clock to 15 kHz */
|
|
|
|
/* the size (in entries) of the 4 polynomial tables */
|
|
const POLY4_SIZE = 0x000f
|
|
const POLY5_SIZE = 0x001f
|
|
const POLY9_SIZE = 0x01ff
|
|
const POLY17_SIZE = 0x0001ffff
|
|
|
|
const CHAN1 = 0
|
|
const CHAN2 = 1
|
|
const CHAN3 = 2
|
|
const CHAN4 = 3
|
|
|
|
const ANTIC_LINE_C = 114
|
|
|
|
/* Some defines about the serial I/O timing. Currently fixed! */
|
|
const SIO_XMTDONE_INTERVAL = 15
|
|
const SIO_SERIN_INTERVAL = 8
|
|
const SIO_SEROUT_INTERVAL = 8
|
|
const SIO_ACK_INTERVAL = 36
|
|
|
|
var poly9: Uint8Array;
|
|
var poly17: Uint8Array;
|
|
|
|
function initPolyTables() {
|
|
poly9 = new Uint8Array(511);
|
|
poly17 = new Uint8Array(16385);
|
|
/* initialise poly9_lookup */
|
|
let reg = 0x1ff;
|
|
for (let i = 0; i < 511; i++) {
|
|
reg = ((((reg >> 5) ^ reg) & 1) << 8) + (reg >> 1);
|
|
poly9[i] = reg;
|
|
}
|
|
/* initialise poly17_lookup */
|
|
reg = 0x1ffff;
|
|
for (let i = 0; i < 16385; i++) {
|
|
reg = ((((reg >> 5) ^ reg) & 0xff) << 9) + (reg >> 8);
|
|
poly17[i] = (reg >> 1);
|
|
}
|
|
}
|
|
|
|
export class POKEY {
|
|
regs = new Uint8Array(16);
|
|
readregs = new Uint8Array(16);
|
|
divnirq = new Uint32Array(4);
|
|
divnmax = new Uint32Array(4);
|
|
pot_inputs = new Uint8Array(8);
|
|
basemult = 0;
|
|
pot_scanline = 0;
|
|
random_scanline_counter = 0;
|
|
kbcode = 0;
|
|
DELAYED_SERIN_IRQ = 0;
|
|
DELAYED_SEROUT_IRQ = 0;
|
|
DELAYED_XMTDONE_IRQ = 0;
|
|
|
|
constructor(
|
|
public irq: () => void,
|
|
public antic_xpos: () => number,
|
|
) {
|
|
this.init();
|
|
}
|
|
|
|
saveState() {
|
|
return safe_extend(0, {}, this);
|
|
}
|
|
loadState(s) {
|
|
safe_extend(0, this, s);
|
|
}
|
|
|
|
init() {
|
|
/* Initialise Serial Port Interrupts */
|
|
//DELAYED_SERIN_IRQ = 0;
|
|
//DELAYED_SEROUT_IRQ = 0;
|
|
//DELAYED_XMTDONE_IRQ = 0;
|
|
this.readregs.fill(0xff);
|
|
this.readregs[SKSTAT] = 0xef;
|
|
//SERIN = 0x00; /* or 0xff ? */
|
|
//IRQEN = 0x00;
|
|
//SKCTL = 0x00;
|
|
this.basemult = DIV_64;
|
|
this.pot_inputs.fill(128);
|
|
initPolyTables();
|
|
}
|
|
|
|
|
|
read(addr: number): number {
|
|
let byte = this.readregs[addr];
|
|
addr &= 0xf;
|
|
switch (addr) {
|
|
case 0: case 1: case 2: case 3:
|
|
case 4: case 5: case 6: case 7:
|
|
byte = this.pot_inputs[addr];
|
|
return (byte < this.pot_scanline) ? byte : this.pot_scanline;
|
|
case ALLPOT:
|
|
for (let i = 0; i < 8; i++) {
|
|
if (this.pot_inputs[i] <= this.pot_scanline)
|
|
byte &= ~(1 << i); // reset bit if pot value known
|
|
}
|
|
break;
|
|
case KBCODE:
|
|
return this.kbcode;
|
|
case SKSTAT:
|
|
byte = SKSTAT + (this.CASSETTE_IOLineStatus() << 4);
|
|
break;
|
|
case RANDOM:
|
|
if ((this.regs[SKCTL] & 0x03) != 0) {
|
|
let i = this.random_scanline_counter + this.antic_xpos();
|
|
if (this.regs[AUDCTL] & POLY9)
|
|
byte = poly9[i % POLY9_SIZE];
|
|
else {
|
|
i %= POLY17_SIZE;
|
|
let ptr = i >> 3;
|
|
i &= 7;
|
|
byte = (poly17[ptr] >> i) + (poly17[ptr + 1] << (8 - i));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return byte & 0xff;
|
|
}
|
|
|
|
write(addr: number, byte: number): void {
|
|
addr &= 0x0f;
|
|
this.regs[addr] = byte;
|
|
switch (addr) {
|
|
case AUDCTL:
|
|
/* determine the base multiplier for the 'div by n' calculations */
|
|
if (byte & CLOCK_15)
|
|
this.basemult = DIV_15;
|
|
else
|
|
this.basemult = DIV_64;
|
|
this.update_counter((1 << CHAN1) | (1 << CHAN2) | (1 << CHAN3) | (1 << CHAN4));
|
|
break;
|
|
case AUDF1:
|
|
this.update_counter((this.regs[AUDCTL] & CH1_CH2) ? ((1 << CHAN2) | (1 << CHAN1)) : (1 << CHAN1));
|
|
break;
|
|
case AUDF2:
|
|
this.update_counter(1 << CHAN2);
|
|
break;
|
|
case AUDF3:
|
|
this.update_counter((this.regs[AUDCTL] & CH3_CH4) ? ((1 << CHAN4) | (1 << CHAN3)) : (1 << CHAN3));
|
|
break;
|
|
case AUDF4:
|
|
this.update_counter(1 << CHAN4);
|
|
break;
|
|
case IRQEN:
|
|
this.readregs[IRQST] |= ~byte & 0xf7; /* Reset disabled IRQs except XMTDONE */
|
|
let mask = ~this.readregs[IRQST] & this.regs[IRQEN];
|
|
if (mask) {
|
|
this.generateIRQ(this.readregs[IRQST]);
|
|
}
|
|
break;
|
|
case SKRES:
|
|
this.readregs[SKSTAT] |= 0xe0;
|
|
break;
|
|
case POTGO:
|
|
if (!(this.regs[SKCTL] & 4))
|
|
this.pot_scanline = 0; /* slow pot mode */
|
|
break;
|
|
case SEROUT:
|
|
if ((this.regs[SKCTL] & 0x70) == 0x20 && this.siocheck()) {
|
|
this.SIO_PutByte(byte);
|
|
}
|
|
// check if cassette 2-tone mode has been enabled
|
|
if ((this.regs[SKCTL] & 0x08) == 0x00) {
|
|
// intelligent device
|
|
this.DELAYED_SEROUT_IRQ = SIO_SEROUT_INTERVAL;
|
|
this.readregs[IRQST] |= 0x08;
|
|
this.DELAYED_XMTDONE_IRQ = SIO_XMTDONE_INTERVAL;
|
|
}
|
|
else {
|
|
// cassette
|
|
// some savers patch the cassette baud rate, so we evaluate it here
|
|
// scanlines per second*10 bit*audiofrequency/(1.79 MHz/2)
|
|
this.DELAYED_SEROUT_IRQ = 312 * 50 * 10 * (this.regs[AUDF3] + this.regs[AUDF4] * 0x100) / 895000;
|
|
// safety check
|
|
if (this.DELAYED_SEROUT_IRQ >= 3) {
|
|
this.readregs[IRQST] |= 0x08;
|
|
this.DELAYED_XMTDONE_IRQ = 2 * this.DELAYED_SEROUT_IRQ - 2;
|
|
}
|
|
else {
|
|
this.DELAYED_SEROUT_IRQ = 0;
|
|
this.DELAYED_XMTDONE_IRQ = 0;
|
|
}
|
|
};
|
|
break;
|
|
case STIMER:
|
|
this.divnirq[CHAN1] = this.divnmax[CHAN1];
|
|
this.divnirq[CHAN2] = this.divnmax[CHAN2];
|
|
this.divnirq[CHAN3] = this.divnmax[CHAN3];
|
|
this.divnirq[CHAN4] = this.divnmax[CHAN4];
|
|
//POKEYSND_Update(STIMER, byte, 0, SOUND_GAIN);
|
|
break;
|
|
case SKCTL:
|
|
//VOICEBOX_SKCTLPutByte(byte);
|
|
//POKEYSND_Update(SKCTL, byte, 0, SOUND_GAIN);
|
|
if (byte & 4)
|
|
this.pot_scanline = 228; /* fast pot mode - return results immediately */
|
|
if ((byte & 0x03) == 0) {
|
|
/* POKEY reset. */
|
|
/* Stop serial IO. */
|
|
this.DELAYED_SERIN_IRQ = 0;
|
|
this.DELAYED_SEROUT_IRQ = 0;
|
|
this.DELAYED_XMTDONE_IRQ = 0;
|
|
// TODO: CASSETTE_ResetPOKEY();
|
|
/* TODO other registers should also be reset. */
|
|
}
|
|
break;
|
|
}
|
|
this.snd_update(addr);
|
|
//POKEYSND_Update(AUDC1, byte, 0, SOUND_GAIN);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Module: Update_Counter() */
|
|
/* Purpose: To process the latest control values stored in the AUDF, AUDC, */
|
|
/* and AUDCTL registers. It pre-calculates as much information as */
|
|
/* possible for better performance. This routine has been added */
|
|
/* here again as I need the precise frequency for the pokey timers */
|
|
/* again. The pokey emulation is therefore somewhat sub-optimal */
|
|
/* since the actual pokey emulation should grab the frequency values */
|
|
/* directly from here instead of calculating them again. */
|
|
/* */
|
|
/* Author: Ron Fries,Thomas Richter */
|
|
/* Date: March 27, 1998 */
|
|
/* */
|
|
/* Inputs: chan_mask: Channel mask, one bit per channel. */
|
|
/* The channels that need to be updated */
|
|
/* */
|
|
/* Outputs: Adjusts local globals - no return value */
|
|
/* */
|
|
/*****************************************************************************/
|
|
|
|
update_counter(chan_mask: number): void {
|
|
|
|
/************************************************************/
|
|
/* As defined in the manual, the exact Div_n_cnt values are */
|
|
/* different depending on the frequency and resolution: */
|
|
/* 64 kHz or 15 kHz - AUDF + 1 */
|
|
/* 1 MHz, 8-bit - AUDF + 4 */
|
|
/* 1 MHz, 16-bit - AUDF[CHAN1]+256*AUDF[CHAN2] + 7 */
|
|
/************************************************************/
|
|
|
|
/* only reset the channels that have changed */
|
|
|
|
if (chan_mask & (1 << CHAN1)) {
|
|
/* process channel 1 frequency */
|
|
if (this.regs[AUDCTL] & CH1_179)
|
|
this.divnmax[CHAN1] = this.regs[AUDF1 + CHAN1] + 4;
|
|
else
|
|
this.divnmax[CHAN1] = (this.regs[AUDF1 + CHAN1] + 1) * this.basemult;
|
|
if (this.divnmax[CHAN1] < ANTIC_LINE_C)
|
|
this.divnmax[CHAN1] = ANTIC_LINE_C;
|
|
}
|
|
|
|
if (chan_mask & (1 << CHAN2)) {
|
|
/* process channel 2 frequency */
|
|
if (this.regs[AUDCTL] & CH1_CH2) {
|
|
if (this.regs[AUDCTL] & CH1_179)
|
|
this.divnmax[CHAN2] = this.regs[AUDF1 + CHAN2] * 256 + this.regs[AUDF1 + CHAN1] + 7;
|
|
else
|
|
this.divnmax[CHAN2] = (this.regs[AUDF1 + CHAN2] * 256 + this.regs[AUDF1 + CHAN1] + 1) * this.basemult;
|
|
}
|
|
else
|
|
this.divnmax[CHAN2] = (this.regs[AUDF1 + CHAN2] + 1) * this.basemult;
|
|
if (this.divnmax[CHAN2] < ANTIC_LINE_C)
|
|
this.divnmax[CHAN2] = ANTIC_LINE_C;
|
|
}
|
|
|
|
if (chan_mask & (1 << CHAN4)) {
|
|
/* process channel 4 frequency */
|
|
if (this.regs[AUDCTL] & CH3_CH4) {
|
|
if (this.regs[AUDCTL] & CH3_179)
|
|
this.divnmax[CHAN4] = this.regs[AUDF1 + CHAN4] * 256 + this.regs[AUDF1 + CHAN3] + 7;
|
|
else
|
|
this.divnmax[CHAN4] = (this.regs[AUDF1 + CHAN4] * 256 + this.regs[AUDF1 + CHAN3] + 1) * this.basemult;
|
|
}
|
|
else
|
|
this.divnmax[CHAN4] = (this.regs[AUDF1 + CHAN4] + 1) * this.basemult;
|
|
if (this.divnmax[CHAN4] < ANTIC_LINE_C)
|
|
this.divnmax[CHAN4] = ANTIC_LINE_C;
|
|
}
|
|
|
|
//console.log(chan_mask, this.divnmax);
|
|
}
|
|
|
|
snd_update(addr: number) {
|
|
|
|
}
|
|
|
|
advanceScanline() {
|
|
/***************************************************************************
|
|
** Generate POKEY Timer IRQs if required **
|
|
** called on a per-scanline basis, not very precise, but good enough **
|
|
** for most applications **
|
|
***************************************************************************/
|
|
|
|
|
|
/* on nonpatched i/o-operation, enable the cassette timing */
|
|
/*
|
|
if (!ESC_enable_sio_patch) {
|
|
if (CASSETTE_AddScanLine())
|
|
DELAYED_SERIN_IRQ = 1;
|
|
}
|
|
*/
|
|
|
|
if ((this.regs[SKCTL] & 0x03) == 0)
|
|
/* Don't process timers when POKEY is in reset mode. */
|
|
return;
|
|
|
|
if (this.pot_scanline < 228)
|
|
this.pot_scanline++;
|
|
|
|
this.random_scanline_counter += ANTIC_LINE_C;
|
|
this.random_scanline_counter %= (this.regs[AUDCTL] & POLY9) ? POLY9_SIZE : POLY17_SIZE;
|
|
|
|
if (this.DELAYED_SERIN_IRQ > 0) {
|
|
if (--this.DELAYED_SERIN_IRQ == 0) {
|
|
// Load a byte to SERIN - even when the IRQ is disabled.
|
|
this.readregs[SERIN] = this.SIO_GetByte();
|
|
this.generateIRQ(0x20);
|
|
}
|
|
}
|
|
|
|
if (this.DELAYED_SEROUT_IRQ > 0) {
|
|
if (--this.DELAYED_SEROUT_IRQ == 0) {
|
|
this.generateIRQ(0x10);
|
|
}
|
|
}
|
|
|
|
if (this.DELAYED_XMTDONE_IRQ > 0)
|
|
if (--this.DELAYED_XMTDONE_IRQ == 0) {
|
|
this.generateIRQ(0x08);
|
|
}
|
|
|
|
this.advanceIRQTimer(CHAN1, 0x1);
|
|
this.advanceIRQTimer(CHAN2, 0x2);
|
|
this.advanceIRQTimer(CHAN4, 0x4);
|
|
}
|
|
|
|
advanceIRQTimer(chan: number, mask: number) {
|
|
if ((this.divnirq[chan] -= ANTIC_LINE_C) < 0) {
|
|
this.divnirq[chan] += this.divnmax[chan];
|
|
this.generateIRQ(mask);
|
|
//console.log('irq', chan, this.divnirq[chan], this.divnmax[chan])
|
|
}
|
|
}
|
|
|
|
generateIRQ(mask: number) {
|
|
if (this.regs[IRQEN] & mask) {
|
|
this.irq();
|
|
this.readregs[IRQST] &= ~mask;
|
|
}
|
|
}
|
|
|
|
static stateToLongString(state): string {
|
|
let s = ''
|
|
s += "Write Registers:\n";
|
|
s += dumpRAM(state.regs, 0, 16);
|
|
s += "Read Registers:\n";
|
|
s += dumpRAM(state.readregs, 0, 16);
|
|
return s;
|
|
}
|
|
|
|
CASSETTE_IOLineStatus() {
|
|
return 0;
|
|
}
|
|
|
|
siocheck() {
|
|
return (((this.regs[AUDF1 + CHAN3] == 0x28 || this.regs[AUDF1 + CHAN3] == 0x10
|
|
|| this.regs[AUDF1 + CHAN3] == 0x08 || this.regs[AUDF1 + CHAN3] == 0x0a)
|
|
&& this.regs[AUDF1 + CHAN4] == 0x00) // intelligent peripherals speeds
|
|
|| (this.regs[SKCTL] & 0x78) == 0x28) // cassette save mode
|
|
&& (this.regs[AUDCTL] & 0x28) == 0x28;
|
|
}
|
|
SIO_PutByte(byte: number) {
|
|
// TODO
|
|
console.log("SIO put byte", byte);
|
|
}
|
|
SIO_GetByte() {
|
|
return 0; // TODO
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//const SOUND_GAIN 4
|
|
/*
|
|
void Frame(void)
|
|
{
|
|
random_scanline_counter %= (this.regs[AUDCTL] & POLY9) ? POLY9_SIZE : POLY17_SIZE;
|
|
}
|
|
*/
|
|
|
|
|
|
|