1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
/*
Fake86: A portable, open-source 8086 PC emulator.
Copyright (C)2010-2013 Mike Chambers
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/* blaster.c: functions to emulate a Creative Labs Sound Blaster Pro. */
#include "config.h"
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "blaster.h"
extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
extern void doirq (uint8_t irqnum);
extern uint8_t read8237 (uint8_t channel);
extern void outadlib (uint16_t portnum, uint8_t value); //on the Sound Blaster Pro, ports (base+0) and (base+1) are for
extern uint8_t inadlib (uint16_t portnum); //the OPL FM music chips, and are also mirrored at (base+8) (base+9)
//as well as 0x388 and 0x389 to remain compatible with the older adlib cards
struct blaster_s blaster;
void bufNewData (uint8_t value) {
if (blaster.memptr >= sizeof (blaster.mem) ) return;
blaster.mem[blaster.memptr] = value;
blaster.memptr++;
}
extern uint64_t hostfreq;
void setsampleticks() {
if (blaster.samplerate == 0) {
blaster.sampleticks = 0;
return;
}
blaster.sampleticks = hostfreq / (uint64_t) blaster.samplerate;
}
void cmdBlaster (uint8_t value) {
uint8_t recognized = 1;
if (blaster.waitforarg) {
switch (blaster.lastcmdval) {
case 0x10: //direct 8-bit sample output
blaster.sample = value;
break;
case 0x14: //8-bit single block DMA output
case 0x24:
case 0x91:
if (blaster.waitforarg == 2) {
blaster.blocksize = (blaster.blocksize & 0xFF00) | (uint32_t) value;
blaster.waitforarg = 3;
return;
}
else {
blaster.blocksize = (blaster.blocksize & 0x00FF) | ( (uint32_t) value << 8);
#ifdef DEBUG_BLASTER
printf ("[NOTICE] Sound Blaster DSP block transfer size set to %u\n", blaster.blocksize);
#endif
blaster.usingdma = 1;
blaster.blockstep = 0;
blaster.useautoinit = 0;
blaster.paused8 = 0;
blaster.speakerstate = 1;
}
break;
case 0x40: //set time constant
blaster.samplerate = (uint16_t) ( (uint32_t) 1000000 / (uint32_t) (256 - (uint32_t) value) );
setsampleticks();
#ifdef DEBUG_BLASTER
printf ("[DEBUG] Sound Blaster time constant received, sample rate = %u\n", blaster.samplerate);
#endif
break;
case 0x48: //set DSP block transfer size
if (blaster.waitforarg == 2) {
blaster.blocksize = (blaster.blocksize & 0xFF00) | (uint32_t) value;
blaster.waitforarg = 3;
return;
}
else {
blaster.blocksize = (blaster.blocksize & 0x00FF) | ( (uint32_t) value << 8);
//if (blaster.blocksize == 0) blaster.blocksize = 65536;
blaster.blockstep = 0;
#ifdef DEBUG_BLASTER
printf ("[NOTICE] Sound Blaster DSP block transfer size set to %u\n", blaster.blocksize);
#endif
}
break;
case 0xE0: //DSP identification for Sound Blaster 2.0 and newer (invert each bit and put in read buffer)
bufNewData (~value);
break;
case 0xE4: //DSP write test, put data value into read buffer
bufNewData (value);
blaster.lasttestval = value;
break;
default:
recognized = 0;
}
//blaster.waitforarg--; // = 0;
if (recognized) return;
}
switch (value) {
case 0x10:
case 0x40:
case 0xE0:
case 0xE4:
blaster.waitforarg = 1;
break;
case 0x14: //8-bit single block DMA output
case 0x24:
case 0x48:
case 0x91:
blaster.waitforarg = 2;
break;
case 0x1C: //8-bit auto-init DMA output
case 0x2C:
blaster.usingdma = 1;
blaster.blockstep = 0;
blaster.useautoinit = 1;
blaster.paused8 = 0;
blaster.speakerstate = 1;
break;
case 0xD0: //pause 8-bit DMA I/O
blaster.paused8 = 1;
case 0xD1: //speaker output on
blaster.speakerstate = 1;
break;
case 0xD3: //speaker output off
blaster.speakerstate = 0;
break;
case 0xD4: //continue 8-bit DMA I/O
blaster.paused8 = 0;
break;
case 0xD8: //get speaker status
if (blaster.speakerstate) bufNewData (0xFF);
else bufNewData (0x00);
break;
case 0xDA: //exit 8-bit auto-init DMA I/O mode
blaster.usingdma = 0;
break;
case 0xE1: //get DSP version info
blaster.memptr = 0;
bufNewData (blaster.dspmaj);
bufNewData (blaster.dspmin);
break;
case 0xE8: //DSP read test
blaster.memptr = 0;
bufNewData (blaster.lasttestval);
break;
case 0xF2: //force 8-bit IRQ
doirq (blaster.sbirq);
break;
case 0xF8: //undocumented command, clears in-buffer and inserts a null byte
blaster.memptr = 0;
bufNewData (0);
break;
default:
printf ("[NOTICE] Sound Blaster received unhandled command %02Xh\n", value);
break;
}
}
uint8_t mixer[256], mixerindex = 0;
void outBlaster (uint16_t portnum, uint8_t value) {
#ifdef DEBUG_BLASTER
printf ("[DEBUG] outBlaster: port %Xh, value %02X\n", portnum, value);
#endif
portnum &= 0xF;
switch (portnum) {
case 0x0:
case 0x8:
outadlib (0x388, value);
break;
case 0x1:
case 0x9:
outadlib (0x389, value);
break;
case 0x4: //mixer address port
mixerindex = value;
break;
case 0x5: //mixer data
mixer[mixerindex] = value;
break;
case 0x6: //reset port
if ( (value == 0x00) && (blaster.lastresetval == 0x01) ) {
blaster.speakerstate = 0;
blaster.sample = 128;
blaster.waitforarg = 0;
blaster.memptr = 0;
blaster.usingdma = 0;
blaster.blocksize = 65535;
blaster.blockstep = 0;
bufNewData (0xAA);
memset (mixer, 0xEE, sizeof (mixer) );
#ifdef DEBUG_BLASTER
printf ("[DEBUG] Sound Blaster received reset!\n");
#endif
}
blaster.lastresetval = value;
break;
case 0xC: //write command/data
cmdBlaster (value);
if (blaster.waitforarg != 3) blaster.lastcmdval = value;
break;
}
}
uint8_t inBlaster (uint16_t portnum) {
uint8_t ret = 0;
#ifdef DEBUG_BLASTER
static uint16_t lastread = 0;
#endif
#ifdef DEBUG_BLASTER
//if (lastread != portnum) printf ("[DEBUG] inBlaster: port %Xh, value ", portnum);
#endif
portnum &= 0xF;
switch (portnum) {
case 0x0:
case 0x8:
ret = inadlib (0x388);
break;
case 0x1:
case 0x9:
ret = inadlib (0x389);
break;
case 0x5: //mixer data
ret = mixer[mixerindex];
break;
case 0xA: //read data
if (blaster.memptr == 0) {
ret = 0;
}
else {
ret = blaster.mem[0];
memmove (&blaster.mem[0], &blaster.mem[1], sizeof (blaster.mem) - 1);
blaster.memptr--;
}
break;
case 0xE: //read-buffer status
if (blaster.memptr > 0) ret = 0x80;
else ret = 0x00;
break;
default:
ret = 0x00;
}
#ifdef DEBUG_BLASTER
//if (lastread != portnum) printf ("%02X\n", ret);
//lastread = portnum;
#endif
return (ret);
}
//FILE *sbout = NULL;
void tickBlaster() {
if (!blaster.usingdma) return;
/*if (blaster.paused8) {
blaster.sample = 128;
return;
}*/
//printf("tickBlaster();\n");
blaster.sample = read8237 (blaster.sbdma);
//if (sbout != NULL) fwrite(&blaster.sample, 1, 1, sbout);
blaster.blockstep++;
if (blaster.blockstep > blaster.blocksize) {
doirq (blaster.sbirq);
#ifdef DEBUG_BLASTER
printf ("[NOTICE] Sound Blaster did IRQ\n");
#endif
if (blaster.useautoinit) {
blaster.blockstep = 0;
}
else {
blaster.usingdma = 0;
}
}
}
int16_t getBlasterSample() {
if (blaster.speakerstate == 0) return (0);
else return ( (int16_t) blaster.sample - 128);
}
void mixerReset() {
memset (blaster.mixer.reg, 0, sizeof (blaster.mixer.reg) );
blaster.mixer.reg[0x22] = blaster.mixer.reg[0x26] = blaster.mixer.reg[0x04] = (4 << 5) | (4 << 1);
}
void initBlaster (uint16_t baseport, uint8_t irq) {
//sbout = fopen("sbout.raw", "wb");
memset (&blaster, 0, sizeof (blaster) );
blaster.dspmaj = 2; //emulate a Sound Blaster 2.0
blaster.dspmin = 0;
blaster.sbirq = irq;
blaster.sbdma = 1;
mixerReset();
set_port_write_redirector (baseport, baseport + 0xE, &outBlaster);
set_port_read_redirector (baseport, baseport + 0xE, &inBlaster);
}
|
