80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

Merge pull request #2029 from jriwanek-forks/ps1-audio

Browse Source 
PS/1 Audio & Tandy Nano
This commit is contained in:
Miran Grča
2022-01-30 16:50:01 +01:00
committed by GitHub
parent d444c5ada8 cfac26f713
commit 3c653fc283
7 changed files with 436 additions and 360 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/include/86box/sound.h
View File

@@ -99,8 +99,12 @@ extern const device_t gus_device;
extern const device_t pas16_device;
#endif
/* IBM PS/1 Audio Card */
extern const device_t ps1snd_device;
/* Tandy PSSJ */
extern const device_t pssj_device;
extern const device_t pssj_isa_device;
/* Creative Labs Sound Blaster */
extern const device_t sb_1_device;

193
src/machine/m_ps1.c
View File

@@ -60,26 +60,11 @@
#include <86box/fdd.h>
#include <86box/fdc.h>
#include <86box/port_6x.h>
#include <86box/sound.h>
#include <86box/snd_sn76489.h>
#include <86box/video.h>
#include <86box/machine.h>
#include <86box/sound.h>
typedef struct {
sn76489_t sn76489;
uint8_t status, ctrl;
uint64_t timer_latch;
pc_timer_t timer_count;
int timer_enable;
uint8_t fifo[2048];
int fifo_read_idx, fifo_write_idx;
int fifo_threshold;
uint8_t dac_val;
int16_t buffer[SOUNDBUFLEN];
int pos;
} ps1snd_t;
typedef struct {
int model;
@@ -100,178 +85,6 @@ typedef struct {
} ps1_t;
static void
update_irq_status(ps1snd_t *snd)
{
if (((snd->status & snd->ctrl) & 0x12) && (snd->ctrl & 0x01))
picint(1 << 7);
else
picintc(1 << 7);
}
static uint8_t
snd_read(uint16_t port, void *priv)
{
ps1snd_t *snd = (ps1snd_t *)priv;
uint8_t ret = 0xff;
switch (port & 7) {
case 0: /* ADC data */
snd->status &= ~0x10;
update_irq_status(snd);
ret = 0;
break;
case 2: /* status */
ret = snd->status;
ret |= (snd->ctrl & 0x01);
if ((snd->fifo_write_idx - snd->fifo_read_idx) >= 2048)
ret |= 0x08; /* FIFO full */
if (snd->fifo_read_idx == snd->fifo_write_idx)
ret |= 0x04; /* FIFO empty */
break;
case 3: /* FIFO timer */
/*
* The PS/1 Technical Reference says this should return
* thecurrent value, but the PS/1 BIOS and Stunt Island
* expect it not to change.
*/
ret = snd->timer_latch;
break;
case 4:
case 5:
case 6:
case 7:
ret = 0;
}
return(ret);
}
static void
snd_write(uint16_t port, uint8_t val, void *priv)
{
ps1snd_t *snd = (ps1snd_t *)priv;
switch (port & 7) {
case 0: /* DAC output */
if ((snd->fifo_write_idx - snd->fifo_read_idx) < 2048) {
snd->fifo[snd->fifo_write_idx & 2047] = val;
snd->fifo_write_idx++;
}
break;
case 2: /* control */
snd->ctrl = val;
if (! (val & 0x02))
snd->status &= ~0x02;
update_irq_status(snd);
break;
case 3: /* timer reload value */
snd->timer_latch = val;
if (val)
timer_set_delay_u64(&snd->timer_count, ((0xff-val) * TIMER_USEC));
else
timer_disable(&snd->timer_count);
break;
case 4: /* almost empty */
snd->fifo_threshold = val * 4;
break;
}
}
static void
snd_update(ps1snd_t *snd)
{
for (; snd->pos < sound_pos_global; snd->pos++)
snd->buffer[snd->pos] = (int8_t)(snd->dac_val ^ 0x80) * 0x20;
}
static void
snd_callback(void *priv)
{
ps1snd_t *snd = (ps1snd_t *)priv;
snd_update(snd);
if (snd->fifo_read_idx != snd->fifo_write_idx) {
snd->dac_val = snd->fifo[snd->fifo_read_idx & 2047];
snd->fifo_read_idx++;
}
if ((snd->fifo_write_idx - snd->fifo_read_idx) == snd->fifo_threshold)
snd->status |= 0x02; /*FIFO almost empty*/
snd->status |= 0x10; /*ADC data ready*/
update_irq_status(snd);
timer_advance_u64(&snd->timer_count, snd->timer_latch * TIMER_USEC);
}
static void
snd_get_buffer(int32_t *buffer, int len, void *priv)
{
ps1snd_t *snd = (ps1snd_t *)priv;
int c;
snd_update(snd);
for (c = 0; c < len * 2; c++)
buffer[c] += snd->buffer[c >> 1];
snd->pos = 0;
}
static void *
snd_init(const device_t *info)
{
ps1snd_t *snd;
snd = malloc(sizeof(ps1snd_t));
memset(snd, 0x00, sizeof(ps1snd_t));
sn76489_init(&snd->sn76489, 0x0205, 0x0001, SN76496, 4000000);
io_sethandler(0x0200, 1, snd_read,NULL,NULL, snd_write,NULL,NULL, snd);
io_sethandler(0x0202, 6, snd_read,NULL,NULL, snd_write,NULL,NULL, snd);
timer_add(&snd->timer_count, snd_callback, snd, 0);
sound_add_handler(snd_get_buffer, snd);
return(snd);
}
static void
snd_close(void *priv)
{
ps1snd_t *snd = (ps1snd_t *)priv;
free(snd);
}
static const device_t snd_device = {
"PS/1 Audio Card",
0, 0,
snd_init, snd_close, NULL,
{ NULL },
NULL,
NULL
};
static void
recalc_memory(ps1_t *ps)
{
@@ -470,7 +283,7 @@ ps1_setup(int model)
lpt2_remove();
device_add(&snd_device);
device_add(&ps1snd_device);
device_add(&fdc_at_ps1_device);
@@ -499,7 +312,7 @@ ps1_setup(int model)
device_add(&ide_isa_device);
device_add(&snd_device);
device_add(&ps1snd_device);
}
}

2
src/sound/CMakeLists.txt
View File

@@ -15,7 +15,7 @@
add_library(snd OBJECT sound.c snd_opl.c snd_opl_nuked.c snd_resid.cc
midi.c midi_rtmidi.cpp snd_speaker.c snd_pssj.c snd_lpt_dac.c snd_ac97_codec.c snd_ac97_via.c
snd_lpt_dss.c snd_adlib.c snd_adlibgold.c snd_ad1848.c snd_audiopci.c
snd_lpt_dss.c snd_ps1.c snd_adlib.c snd_adlibgold.c snd_ad1848.c snd_audiopci.c
snd_azt2316a.c snd_cms.c snd_cs423x.c snd_gus.c snd_sb.c snd_sb_dsp.c
snd_emu8k.c snd_mpu401.c snd_sn76489.c snd_ssi2001.c snd_wss.c snd_ym7128.c)

201
src/sound/snd_ps1.c Normal file
View File

@@ -0,0 +1,201 @@
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#define HAVE_STDARG_H
#include <86box/86box.h>
#include <86box/io.h>
#include <86box/pic.h>
#include <86box/timer.h>
#include <86box/device.h>
#include <86box/sound.h>
#include <86box/snd_sn76489.h>
typedef struct {
sn76489_t sn76489;
uint8_t status, ctrl;
uint64_t timer_latch;
pc_timer_t timer_count;
int timer_enable;
uint8_t fifo[2048];
int fifo_read_idx, fifo_write_idx;
int fifo_threshold;
uint8_t dac_val;
int16_t buffer[SOUNDBUFLEN];
int pos;
} ps1snd_t;
static void
ps1snd_update_irq_status(ps1snd_t *snd)
{
if (((snd->status & snd->ctrl) & 0x12) && (snd->ctrl & 0x01))
picint(1 << 7);
else
picintc(1 << 7);
}
static uint8_t
ps1snd_read(uint16_t port, void *priv)
{
ps1snd_t *ps1snd = (ps1snd_t *)priv;
uint8_t ret = 0xff;
switch (port & 7) {
case 0: /* ADC data */
ps1snd->status &= ~0x10;
ps1snd_update_irq_status(ps1snd);
ret = 0;
break;
case 2: /* status */
ret = ps1snd->status;
ret |= (ps1snd->ctrl & 0x01);
if ((ps1snd->fifo_write_idx - ps1snd->fifo_read_idx) >= 2048)
ret |= 0x08; /* FIFO full */
if (ps1snd->fifo_read_idx == ps1snd->fifo_write_idx)
ret |= 0x04; /* FIFO empty */
break;
case 3: /* FIFO timer */
/*
* The PS/1 Technical Reference says this should return
* thecurrent value, but the PS/1 BIOS and Stunt Island
* expect it not to change.
*/
ret = ps1snd->timer_latch;
break;
case 4:
case 5:
case 6:
case 7:
ret = 0;
}
return(ret);
}
static void
ps1snd_write(uint16_t port, uint8_t val, void *priv)
{
ps1snd_t *ps1snd = (ps1snd_t *)priv;
switch (port & 7) {
case 0: /* DAC output */
if ((ps1snd->fifo_write_idx - ps1snd->fifo_read_idx) < 2048) {
ps1snd->fifo[ps1snd->fifo_write_idx & 2047] = val;
ps1snd->fifo_write_idx++;
}
break;
case 2: /* control */
ps1snd->ctrl = val;
if (! (val & 0x02))
ps1snd->status &= ~0x02;
ps1snd_update_irq_status(ps1snd);
break;
case 3: /* timer reload value */
ps1snd->timer_latch = val;
if (val)
timer_set_delay_u64(&ps1snd->timer_count, ((0xff-val) * TIMER_USEC));
else
timer_disable(&ps1snd->timer_count);
break;
case 4: /* almost empty */
ps1snd->fifo_threshold = val * 4;
break;
}
}
static void
ps1snd_update(ps1snd_t *ps1snd)
{
for (; ps1snd->pos < sound_pos_global; ps1snd->pos++)
ps1snd->buffer[ps1snd->pos] = (int8_t)(ps1snd->dac_val ^ 0x80) * 0x20;
}
static void
ps1snd_callback(void *priv)
{
ps1snd_t *ps1snd = (ps1snd_t *)priv;
ps1snd_update(ps1snd);
if (ps1snd->fifo_read_idx != ps1snd->fifo_write_idx) {
ps1snd->dac_val = ps1snd->fifo[ps1snd->fifo_read_idx & 2047];
ps1snd->fifo_read_idx++;
}
if ((ps1snd->fifo_write_idx - ps1snd->fifo_read_idx) == ps1snd->fifo_threshold)
ps1snd->status |= 0x02; /*FIFO almost empty*/
ps1snd->status |= 0x10; /*ADC data ready*/
ps1snd_update_irq_status(ps1snd);
timer_advance_u64(&ps1snd->timer_count, ps1snd->timer_latch * TIMER_USEC);
}
static void
ps1snd_get_buffer(int32_t *buffer, int len, void *priv)
{
ps1snd_t *ps1snd = (ps1snd_t *)priv;
int c;
ps1snd_update(ps1snd);
for (c = 0; c < len * 2; c++)
buffer[c] += ps1snd->buffer[c >> 1];
ps1snd->pos = 0;
}
static void *
ps1snd_init(const device_t *info)
{
ps1snd_t *ps1snd = malloc(sizeof(ps1snd_t));
memset(ps1snd, 0x00, sizeof(ps1snd_t));
sn76489_init(&ps1snd->sn76489, 0x0205, 0x0001, SN76496, 4000000);
io_sethandler(0x0200, 1, ps1snd_read,NULL,NULL, ps1snd_write,NULL,NULL, ps1snd);
io_sethandler(0x0202, 6, ps1snd_read,NULL,NULL, ps1snd_write,NULL,NULL, ps1snd);
timer_add(&ps1snd->timer_count, ps1snd_callback, ps1snd, 0);
sound_add_handler(ps1snd_get_buffer, ps1snd);
return(ps1snd);
}
static void
ps1snd_close(void *priv)
{
ps1snd_t *ps1snd = (ps1snd_t *)priv;
free(ps1snd);
}
const device_t ps1snd_device = {
"IBM PS/1 Audio Card",
0, 0,
ps1snd_init, ps1snd_close,
NULL,
{ NULL },
NULL,
NULL,
NULL
};

394
src/sound/snd_pssj.c
View File

@@ -15,233 +15,289 @@
typedef struct pssj_t
{
sn76489_t sn76489;
uint8_t ctrl;
uint8_t wave;
uint8_t dac_val;
uint16_t freq;
int amplitude;
int irq;
pc_timer_t timer_count;
int enable;
int wave_pos;
int pulse_width;
sn76489_t sn76489;
int16_t buffer[SOUNDBUFLEN];
int pos;
uint8_t ctrl;
uint8_t wave;
uint8_t dac_val;
uint16_t freq;
int amplitude;
int irq;
pc_timer_t timer_count;
int enable;
int wave_pos;
int pulse_width;
int16_t buffer[SOUNDBUFLEN];
int pos;
} pssj_t;
static void pssj_update_irq(pssj_t *pssj)
{
if (pssj->irq && (pssj->ctrl & 0x10) && (pssj->ctrl & 0x08))
picint(1 << 7);
if (pssj->irq && (pssj->ctrl & 0x10) && (pssj->ctrl & 0x08))
picint(1 << 7);
}
static void pssj_write(uint16_t port, uint8_t val, void *p)
{
pssj_t *pssj = (pssj_t *)p;
pssj_t *pssj = (pssj_t *)p;
switch (port & 3)
{
case 0:
pssj->ctrl = val;
if (!pssj->enable && ((val & 4) && (pssj->ctrl & 3)))
timer_set_delay_u64(&pssj->timer_count, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
pssj->enable = (val & 4) && (pssj->ctrl & 3);
if (!pssj->enable)
timer_disable(&pssj->timer_count);
sn74689_set_extra_divide(&pssj->sn76489, val & 0x40);
if (!(val & 8))
pssj->irq = 0;
pssj_update_irq(pssj);
break;
case 1:
switch (pssj->ctrl & 3)
{
case 1: /*Sound channel*/
pssj->wave = val;
pssj->pulse_width = val & 7;
break;
case 3: /*Direct DAC*/
pssj->dac_val = val;
break;
}
break;
case 2:
pssj->freq = (pssj->freq & 0xf00) | val;
break;
case 3:
pssj->freq = (pssj->freq & 0x0ff) | ((val & 0xf) << 8);
pssj->amplitude = val >> 4;
break;
}
switch (port & 3)
{
case 0:
pssj->ctrl = val;
if (!pssj->enable && ((val & 4) && (pssj->ctrl & 3)))
timer_set_delay_u64(&pssj->timer_count, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
pssj->enable = (val & 4) && (pssj->ctrl & 3);
if (!pssj->enable)
timer_disable(&pssj->timer_count);
sn74689_set_extra_divide(&pssj->sn76489, val & 0x40);
if (!(val & 8))
pssj->irq = 0;
pssj_update_irq(pssj);
break;
case 1:
switch (pssj->ctrl & 3)
{
case 1: /*Sound channel*/
pssj->wave = val;
pssj->pulse_width = val & 7;
break;
case 3: /*Direct DAC*/
pssj->dac_val = val;
break;
}
break;
case 2:
pssj->freq = (pssj->freq & 0xf00) | val;
break;
case 3:
pssj->freq = (pssj->freq & 0x0ff) | ((val & 0xf) << 8);
pssj->amplitude = val >> 4;
break;
}
}
static uint8_t pssj_read(uint16_t port, void *p)
{
pssj_t *pssj = (pssj_t *)p;
switch (port & 3)
{
case 0:
return (pssj->ctrl & ~0x88) | (pssj->irq ? 8 : 0);
case 1:
switch (pssj->ctrl & 3)
{
case 0: /*Joystick*/
return 0;
case 1: /*Sound channel*/
return pssj->wave;
case 2: /*Successive approximation*/
return 0x80;
case 3: /*Direct DAC*/
return pssj->dac_val;
}
break;
case 2:
return pssj->freq & 0xff;
case 3:
return (pssj->freq >> 8) | (pssj->amplitude << 4);
default:
return 0xff;
}
pssj_t *pssj = (pssj_t *)p;
return 0xff;
switch (port & 3)
{
case 0:
return (pssj->ctrl & ~0x88) | (pssj->irq ? 8 : 0);
case 1:
switch (pssj->ctrl & 3)
{
case 0: /*Joystick*/
return 0;
case 1: /*Sound channel*/
return pssj->wave;
case 2: /*Successive approximation*/
return 0x80;
case 3: /*Direct DAC*/
return pssj->dac_val;
}
break;
case 2:
return pssj->freq & 0xff;
case 3:
return (pssj->freq >> 8) | (pssj->amplitude << 4);
default:
return 0xff;
}
return 0xff;
}
static void pssj_update(pssj_t *pssj)
{
for (; pssj->pos < sound_pos_global; pssj->pos++)
pssj->buffer[pssj->pos] = (((int8_t)(pssj->dac_val ^ 0x80) * 0x20) * pssj->amplitude) / 15;
for (; pssj->pos < sound_pos_global; pssj->pos++)
pssj->buffer[pssj->pos] = (((int8_t)(pssj->dac_val ^ 0x80) * 0x20) * pssj->amplitude) / 15;
}
static void pssj_callback(void *p)
{
pssj_t *pssj = (pssj_t *)p;
int data;
pssj_t *pssj = (pssj_t *)p;
int data;
pssj_update(pssj);
if (pssj->ctrl & 2)
pssj_update(pssj);
if (pssj->ctrl & 2)
{
if ((pssj->ctrl & 3) == 3)
{
if ((pssj->ctrl & 3) == 3)
{
data = dma_channel_read(1);
data = dma_channel_read(1);
if (data != DMA_NODATA)
{
pssj->dac_val = data & 0xff;
}
}
else
{
data = dma_channel_write(1, 0x80);
}
if ((data & DMA_OVER) && data != DMA_NODATA)
{
if (pssj->ctrl & 0x08)
{
pssj->irq = 1;
pssj_update_irq(pssj);
}
}
if (data != DMA_NODATA)
{
pssj->dac_val = data & 0xff;
}
}
else
{
switch (pssj->wave & 0xc0)
{
case 0x00: /*Pulse*/
pssj->dac_val = (pssj->wave_pos > (pssj->pulse_width << 1)) ? 0xff : 0;
break;
case 0x40: /*Ramp*/
pssj->dac_val = pssj->wave_pos << 3;
break;
case 0x80: /*Triangle*/
if (pssj->wave_pos & 16)
pssj->dac_val = (pssj->wave_pos ^ 31) << 4;
else
pssj->dac_val = pssj->wave_pos << 4;
break;
case 0xc0:
pssj->dac_val = 0x80;
break;
}
pssj->wave_pos = (pssj->wave_pos + 1) & 31;
data = dma_channel_write(1, 0x80);
}
timer_advance_u64(&pssj->timer_count, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
if ((data & DMA_OVER) && data != DMA_NODATA)
{
if (pssj->ctrl & 0x08)
{
pssj->irq = 1;
pssj_update_irq(pssj);
}
}
}
else
{
switch (pssj->wave & 0xc0)
{
case 0x00: /*Pulse*/
pssj->dac_val = (pssj->wave_pos > (pssj->pulse_width << 1)) ? 0xff : 0;
break;
case 0x40: /*Ramp*/
pssj->dac_val = pssj->wave_pos << 3;
break;
case 0x80: /*Triangle*/
if (pssj->wave_pos & 16)
pssj->dac_val = (pssj->wave_pos ^ 31) << 4;
else
pssj->dac_val = pssj->wave_pos << 4;
break;
case 0xc0:
pssj->dac_val = 0x80;
break;
}
pssj->wave_pos = (pssj->wave_pos + 1) & 31;
}
timer_advance_u64(&pssj->timer_count, (TIMER_USEC * (1000000.0 / 3579545.0) * (double)(pssj->freq ? pssj->freq : 0x400)));
}
static void pssj_get_buffer(int32_t *buffer, int len, void *p)
{
pssj_t *pssj = (pssj_t *)p;
int c;
pssj_update(pssj);
for (c = 0; c < len * 2; c++)
buffer[c] += pssj->buffer[c >> 1];
pssj_t *pssj = (pssj_t *)p;
int c;
pssj->pos = 0;
pssj_update(pssj);
for (c = 0; c < len * 2; c++)
buffer[c] += pssj->buffer[c >> 1];
pssj->pos = 0;
}
void *pssj_init(const device_t *info)
{
pssj_t *pssj = malloc(sizeof(pssj_t));
memset(pssj, 0, sizeof(pssj_t));
pssj_t *pssj = malloc(sizeof(pssj_t));
memset(pssj, 0, sizeof(pssj_t));
sn76489_init(&pssj->sn76489, 0x00c0, 0x0004, PSSJ, 3579545);
sn76489_init(&pssj->sn76489, 0x00c0, 0x0004, PSSJ, 3579545);
io_sethandler(0x00C4, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
timer_add(&pssj->timer_count, pssj_callback, pssj, pssj->enable);
sound_add_handler(pssj_get_buffer, pssj);
return pssj;
io_sethandler(0x00C4, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
timer_add(&pssj->timer_count, pssj_callback, pssj, pssj->enable);
sound_add_handler(pssj_get_buffer, pssj);
return pssj;
}
void *pssj_1e0_init(const device_t *info)
{
pssj_t *pssj = malloc(sizeof(pssj_t));
memset(pssj, 0, sizeof(pssj_t));
pssj_t *pssj = malloc(sizeof(pssj_t));
memset(pssj, 0, sizeof(pssj_t));
sn76489_init(&pssj->sn76489, 0x01e0, 0x0004, PSSJ, 3579545);
sn76489_init(&pssj->sn76489, 0x01e0, 0x0004, PSSJ, 3579545);
io_sethandler(0x01E4, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
timer_add(&pssj->timer_count, pssj_callback, pssj, pssj->enable);
sound_add_handler(pssj_get_buffer, pssj);
return pssj;
io_sethandler(0x01E4, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
timer_add(&pssj->timer_count, pssj_callback, pssj, pssj->enable);
sound_add_handler(pssj_get_buffer, pssj);
return pssj;
}
void *pssj_isa_init(const device_t *info)
{
pssj_t *pssj = malloc(sizeof(pssj_t));
memset(pssj, 0, sizeof(pssj_t));
sn76489_init(&pssj->sn76489, 0x00c0, 0x0004, PSSJ, 3579545);
uint16_t addr = device_get_config_hex16("base");
io_sethandler(addr, 0x0004, pssj_read, NULL, NULL, pssj_write, NULL, NULL, pssj);
timer_add(&pssj->timer_count, pssj_callback, pssj, pssj->enable);
sound_add_handler(pssj_get_buffer, pssj);
return pssj;
}
void pssj_close(void *p)
{
pssj_t *pssj = (pssj_t *)p;
pssj_t *pssj = (pssj_t *)p;
free(pssj);
free(pssj);
}
static const device_config_t pssj_isa_config[] =
{
{
"base", "Address", CONFIG_HEX16, "", 0xC0, "", { 0 },
{
{
"0xC0", 0xC0
},
{
"0x1E0", 0x1E0
},
{
"0x2C0", 0x2C0
},
{
""
}
}
},
{
"", "", -1
}
};
const device_t pssj_device =
{
"Tandy PSSJ",
0, 0,
pssj_init,
pssj_close,
NULL,
{ NULL },
NULL,
NULL
"Tandy PSSJ",
0,
0,
pssj_init,
pssj_close,
NULL,
{ NULL },
NULL,
NULL
};
const device_t pssj_1e0_device =
{
"Tandy PSSJ (port 1e0h)",
0, 0,
pssj_1e0_init,
pssj_close,
NULL,
{ NULL },
NULL,
NULL
"Tandy PSSJ (port 1e0h)",
0,
0,
pssj_1e0_init,
pssj_close,
NULL,
{ NULL },
NULL,
NULL
};
const device_t pssj_isa_device =
{
"Tandy PSSJ (ISA Clone)",
DEVICE_ISA,
0,
pssj_isa_init,
pssj_close,
NULL,
{ NULL },
NULL,
NULL,
pssj_isa_config
};

1
src/sound/sound.c
View File

@@ -85,6 +85,7 @@ static const SOUND_CARD sound_cards[] =
{
{ "none", NULL },
{ "internal", NULL },
{ "pssj_isa", &pssj_isa_device },
{ "adlib", &adlib_device },
{ "adlibgold", &adgold_device },
{ "azt2316a", &azt2316a_device },

1
src/win/Makefile.mingw
View File

@@ -650,6 +650,7 @@ SNDOBJ := sound.o \
midi.o midi_rtmidi.o \
snd_speaker.o \
snd_pssj.o \
snd_ps1.o \
snd_lpt_dac.o snd_lpt_dss.o \
snd_adlib.o snd_adlibgold.o snd_ad1848.o snd_audiopci.o \
snd_ac97_codec.o snd_ac97_via.o \