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