1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "hw/hw.h"
25#include "hw/audio/audio.h"
26#include "audio/audio.h"
27#include "hw/isa/isa.h"
28#include "gusemu.h"
29#include "gustate.h"
30
31#define dolog(...) AUD_log ("audio", __VA_ARGS__)
32#ifdef DEBUG
33#define ldebug(...) dolog (__VA_ARGS__)
34#else
35#define ldebug(...)
36#endif
37
38#ifdef HOST_WORDS_BIGENDIAN
39#define GUS_ENDIANNESS 1
40#else
41#define GUS_ENDIANNESS 0
42#endif
43
44#define IO_READ_PROTO(name) \
45 static uint32_t name (void *opaque, uint32_t nport)
46#define IO_WRITE_PROTO(name) \
47 static void name (void *opaque, uint32_t nport, uint32_t val)
48
49#define TYPE_GUS "gus"
50#define GUS(obj) OBJECT_CHECK (GUSState, (obj), TYPE_GUS)
51
52typedef struct GUSState {
53 ISADevice dev;
54 GUSEmuState emu;
55 QEMUSoundCard card;
56 uint32_t freq;
57 uint32_t port;
58 int pos, left, shift, irqs;
59 GUSsample *mixbuf;
60 uint8_t himem[1024 * 1024 + 32 + 4096];
61 int samples;
62 SWVoiceOut *voice;
63 int64_t last_ticks;
64 qemu_irq pic;
65} GUSState;
66
67IO_READ_PROTO (gus_readb)
68{
69 GUSState *s = opaque;
70
71 return gus_read (&s->emu, nport, 1);
72}
73
74IO_READ_PROTO (gus_readw)
75{
76 GUSState *s = opaque;
77
78 return gus_read (&s->emu, nport, 2);
79}
80
81IO_WRITE_PROTO (gus_writeb)
82{
83 GUSState *s = opaque;
84
85 gus_write (&s->emu, nport, 1, val);
86}
87
88IO_WRITE_PROTO (gus_writew)
89{
90 GUSState *s = opaque;
91
92 gus_write (&s->emu, nport, 2, val);
93}
94
95static int write_audio (GUSState *s, int samples)
96{
97 int net = 0;
98 int pos = s->pos;
99
100 while (samples) {
101 int nbytes, wbytes, wsampl;
102
103 nbytes = samples << s->shift;
104 wbytes = AUD_write (
105 s->voice,
106 s->mixbuf + (pos << (s->shift - 1)),
107 nbytes
108 );
109
110 if (wbytes) {
111 wsampl = wbytes >> s->shift;
112
113 samples -= wsampl;
114 pos = (pos + wsampl) % s->samples;
115
116 net += wsampl;
117 }
118 else {
119 break;
120 }
121 }
122
123 return net;
124}
125
126static void GUS_callback (void *opaque, int free)
127{
128 int samples, to_play, net = 0;
129 GUSState *s = opaque;
130
131 samples = free >> s->shift;
132 to_play = audio_MIN (samples, s->left);
133
134 while (to_play) {
135 int written = write_audio (s, to_play);
136
137 if (!written) {
138 goto reset;
139 }
140
141 s->left -= written;
142 to_play -= written;
143 samples -= written;
144 net += written;
145 }
146
147 samples = audio_MIN (samples, s->samples);
148 if (samples) {
149 gus_mixvoices (&s->emu, s->freq, samples, s->mixbuf);
150
151 while (samples) {
152 int written = write_audio (s, samples);
153 if (!written) {
154 break;
155 }
156 samples -= written;
157 net += written;
158 }
159 }
160 s->left = samples;
161
162 reset:
163 gus_irqgen (&s->emu, muldiv64 (net, 1000000, s->freq));
164}
165
166int GUS_irqrequest (GUSEmuState *emu, int hwirq, int n)
167{
168 GUSState *s = emu->opaque;
169
170 qemu_irq_raise (s->pic);
171 s->irqs += n;
172 ldebug ("irqrequest %d %d %d\n", hwirq, n, s->irqs);
173 return n;
174}
175
176void GUS_irqclear (GUSEmuState *emu, int hwirq)
177{
178 GUSState *s = emu->opaque;
179 ldebug ("irqclear %d %d\n", hwirq, s->irqs);
180 qemu_irq_lower (s->pic);
181 s->irqs -= 1;
182#ifdef IRQ_STORM
183 if (s->irqs > 0) {
184 qemu_irq_raise (s->pic[hwirq]);
185 }
186#endif
187}
188
189void GUS_dmarequest (GUSEmuState *der)
190{
191
192 ldebug ("dma request %d\n", der->gusdma);
193 DMA_hold_DREQ (der->gusdma);
194}
195
196static int GUS_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
197{
198 GUSState *s = opaque;
199 char tmpbuf[4096];
200 int pos = dma_pos, mode, left = dma_len - dma_pos;
201
202 ldebug ("read DMA %#x %d\n", dma_pos, dma_len);
203 mode = DMA_get_channel_mode (s->emu.gusdma);
204 while (left) {
205 int to_copy = audio_MIN ((size_t) left, sizeof (tmpbuf));
206 int copied;
207
208 ldebug ("left=%d to_copy=%d pos=%d\n", left, to_copy, pos);
209 copied = DMA_read_memory (nchan, tmpbuf, pos, to_copy);
210 gus_dma_transferdata (&s->emu, tmpbuf, copied, left == copied);
211 left -= copied;
212 pos += copied;
213 }
214
215 if (((mode >> 4) & 1) == 0) {
216 DMA_release_DREQ (s->emu.gusdma);
217 }
218 return dma_len;
219}
220
221static const VMStateDescription vmstate_gus = {
222 .name = "gus",
223 .version_id = 2,
224 .minimum_version_id = 2,
225 .fields = (VMStateField[]) {
226 VMSTATE_INT32 (pos, GUSState),
227 VMSTATE_INT32 (left, GUSState),
228 VMSTATE_INT32 (shift, GUSState),
229 VMSTATE_INT32 (irqs, GUSState),
230 VMSTATE_INT32 (samples, GUSState),
231 VMSTATE_INT64 (last_ticks, GUSState),
232 VMSTATE_BUFFER (himem, GUSState),
233 VMSTATE_END_OF_LIST ()
234 }
235};
236
237static const MemoryRegionPortio gus_portio_list1[] = {
238 {0x000, 1, 1, .write = gus_writeb },
239 {0x000, 1, 2, .write = gus_writew },
240 {0x006, 10, 1, .read = gus_readb, .write = gus_writeb },
241 {0x006, 10, 2, .read = gus_readw, .write = gus_writew },
242 {0x100, 8, 1, .read = gus_readb, .write = gus_writeb },
243 {0x100, 8, 2, .read = gus_readw, .write = gus_writew },
244 PORTIO_END_OF_LIST (),
245};
246
247static const MemoryRegionPortio gus_portio_list2[] = {
248 {0, 1, 1, .read = gus_readb },
249 {0, 1, 2, .read = gus_readw },
250 PORTIO_END_OF_LIST (),
251};
252
253static void gus_realizefn (DeviceState *dev, Error **errp)
254{
255 ISADevice *d = ISA_DEVICE(dev);
256 GUSState *s = GUS (dev);
257 struct audsettings as;
258
259 AUD_register_card ("gus", &s->card);
260
261 as.freq = s->freq;
262 as.nchannels = 2;
263 as.fmt = AUD_FMT_S16;
264 as.endianness = GUS_ENDIANNESS;
265
266 s->voice = AUD_open_out (
267 &s->card,
268 NULL,
269 "gus",
270 s,
271 GUS_callback,
272 &as
273 );
274
275 if (!s->voice) {
276 AUD_remove_card (&s->card);
277 error_setg(errp, "No voice");
278 return;
279 }
280
281 s->shift = 2;
282 s->samples = AUD_get_buffer_size_out (s->voice) >> s->shift;
283 s->mixbuf = g_malloc0 (s->samples << s->shift);
284
285 isa_register_portio_list (d, s->port, gus_portio_list1, s, "gus");
286 isa_register_portio_list (d, (s->port + 0x100) & 0xf00,
287 gus_portio_list2, s, "gus");
288
289 DMA_register_channel (s->emu.gusdma, GUS_read_DMA, s);
290 s->emu.himemaddr = s->himem;
291 s->emu.gusdatapos = s->emu.himemaddr + 1024 * 1024 + 32;
292 s->emu.opaque = s;
293 isa_init_irq (d, &s->pic, s->emu.gusirq);
294
295 AUD_set_active_out (s->voice, 1);
296}
297
298static int GUS_init (ISABus *bus)
299{
300 isa_create_simple (bus, TYPE_GUS);
301 return 0;
302}
303
304static Property gus_properties[] = {
305 DEFINE_PROP_UINT32 ("freq", GUSState, freq, 44100),
306 DEFINE_PROP_UINT32 ("iobase", GUSState, port, 0x240),
307 DEFINE_PROP_UINT32 ("irq", GUSState, emu.gusirq, 7),
308 DEFINE_PROP_UINT32 ("dma", GUSState, emu.gusdma, 3),
309 DEFINE_PROP_END_OF_LIST (),
310};
311
312static void gus_class_initfn (ObjectClass *klass, void *data)
313{
314 DeviceClass *dc = DEVICE_CLASS (klass);
315
316 dc->realize = gus_realizefn;
317 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
318 dc->desc = "Gravis Ultrasound GF1";
319 dc->vmsd = &vmstate_gus;
320 dc->props = gus_properties;
321}
322
323static const TypeInfo gus_info = {
324 .name = TYPE_GUS,
325 .parent = TYPE_ISA_DEVICE,
326 .instance_size = sizeof (GUSState),
327 .class_init = gus_class_initfn,
328};
329
330static void gus_register_types (void)
331{
332 type_register_static (&gus_info);
333 isa_register_soundhw("gus", "Gravis Ultrasound GF1", GUS_init);
334}
335
336type_init (gus_register_types)
337
