1 | /* |
2 | * QEMU Proxy for Gravis Ultrasound GF1 emulation by Tibor "TS" Schütz |
3 | * |
4 | * Copyright (c) 2002-2005 Vassili Karpov (malc) |
5 | * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal |
8 | * in the Software without restriction, including without limitation the rights |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
10 | * copies of the Software, and to permit persons to whom the Software is |
11 | * furnished to do so, subject to the following conditions: |
12 | * |
13 | * The above copyright notice and this permission notice shall be included in |
14 | * all copies or substantial portions of the Software. |
15 | * |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
22 | * THE SOFTWARE. |
23 | */ |
24 | |
25 | #include "qemu/osdep.h" |
26 | #include "qapi/error.h" |
27 | #include "qemu/module.h" |
28 | #include "hw/audio/soundhw.h" |
29 | #include "audio/audio.h" |
30 | #include "hw/irq.h" |
31 | #include "hw/isa/isa.h" |
32 | #include "hw/qdev-properties.h" |
33 | #include "migration/vmstate.h" |
34 | #include "gusemu.h" |
35 | #include "gustate.h" |
36 | |
37 | #define dolog(...) AUD_log ("audio", __VA_ARGS__) |
38 | #ifdef DEBUG |
39 | #define ldebug(...) dolog (__VA_ARGS__) |
40 | #else |
41 | #define ldebug(...) |
42 | #endif |
43 | |
44 | #ifdef HOST_WORDS_BIGENDIAN |
45 | #define GUS_ENDIANNESS 1 |
46 | #else |
47 | #define GUS_ENDIANNESS 0 |
48 | #endif |
49 | |
50 | #define TYPE_GUS "gus" |
51 | #define GUS(obj) OBJECT_CHECK (GUSState, (obj), TYPE_GUS) |
52 | |
53 | typedef struct GUSState { |
54 | ISADevice dev; |
55 | GUSEmuState emu; |
56 | QEMUSoundCard card; |
57 | uint32_t freq; |
58 | uint32_t port; |
59 | int pos, left, shift, irqs; |
60 | int16_t *mixbuf; |
61 | uint8_t himem[1024 * 1024 + 32 + 4096]; |
62 | int samples; |
63 | SWVoiceOut *voice; |
64 | int64_t last_ticks; |
65 | qemu_irq pic; |
66 | IsaDma *isa_dma; |
67 | PortioList portio_list1; |
68 | PortioList portio_list2; |
69 | } GUSState; |
70 | |
71 | static uint32_t gus_readb(void *opaque, uint32_t nport) |
72 | { |
73 | GUSState *s = opaque; |
74 | |
75 | return gus_read (&s->emu, nport, 1); |
76 | } |
77 | |
78 | static void gus_writeb(void *opaque, uint32_t nport, uint32_t val) |
79 | { |
80 | GUSState *s = opaque; |
81 | |
82 | gus_write (&s->emu, nport, 1, val); |
83 | } |
84 | |
85 | static int write_audio (GUSState *s, int samples) |
86 | { |
87 | int net = 0; |
88 | int pos = s->pos; |
89 | |
90 | while (samples) { |
91 | int nbytes, wbytes, wsampl; |
92 | |
93 | nbytes = samples << s->shift; |
94 | wbytes = AUD_write ( |
95 | s->voice, |
96 | s->mixbuf + (pos << (s->shift - 1)), |
97 | nbytes |
98 | ); |
99 | |
100 | if (wbytes) { |
101 | wsampl = wbytes >> s->shift; |
102 | |
103 | samples -= wsampl; |
104 | pos = (pos + wsampl) % s->samples; |
105 | |
106 | net += wsampl; |
107 | } |
108 | else { |
109 | break; |
110 | } |
111 | } |
112 | |
113 | return net; |
114 | } |
115 | |
116 | static void GUS_callback (void *opaque, int free) |
117 | { |
118 | int samples, to_play, net = 0; |
119 | GUSState *s = opaque; |
120 | |
121 | samples = free >> s->shift; |
122 | to_play = MIN (samples, s->left); |
123 | |
124 | while (to_play) { |
125 | int written = write_audio (s, to_play); |
126 | |
127 | if (!written) { |
128 | goto reset; |
129 | } |
130 | |
131 | s->left -= written; |
132 | to_play -= written; |
133 | samples -= written; |
134 | net += written; |
135 | } |
136 | |
137 | samples = MIN (samples, s->samples); |
138 | if (samples) { |
139 | gus_mixvoices (&s->emu, s->freq, samples, s->mixbuf); |
140 | |
141 | while (samples) { |
142 | int written = write_audio (s, samples); |
143 | if (!written) { |
144 | break; |
145 | } |
146 | samples -= written; |
147 | net += written; |
148 | } |
149 | } |
150 | s->left = samples; |
151 | |
152 | reset: |
153 | gus_irqgen (&s->emu, (uint64_t)net * 1000000 / s->freq); |
154 | } |
155 | |
156 | int GUS_irqrequest (GUSEmuState *emu, int hwirq, int n) |
157 | { |
158 | GUSState *s = emu->opaque; |
159 | /* qemu_irq_lower (s->pic); */ |
160 | qemu_irq_raise (s->pic); |
161 | s->irqs += n; |
162 | ldebug ("irqrequest %d %d %d\n" , hwirq, n, s->irqs); |
163 | return n; |
164 | } |
165 | |
166 | void GUS_irqclear (GUSEmuState *emu, int hwirq) |
167 | { |
168 | GUSState *s = emu->opaque; |
169 | ldebug ("irqclear %d %d\n" , hwirq, s->irqs); |
170 | qemu_irq_lower (s->pic); |
171 | s->irqs -= 1; |
172 | #ifdef IRQ_STORM |
173 | if (s->irqs > 0) { |
174 | qemu_irq_raise (s->pic[hwirq]); |
175 | } |
176 | #endif |
177 | } |
178 | |
179 | void GUS_dmarequest (GUSEmuState *emu) |
180 | { |
181 | GUSState *s = emu->opaque; |
182 | IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma); |
183 | ldebug ("dma request %d\n" , der->gusdma); |
184 | k->hold_DREQ(s->isa_dma, s->emu.gusdma); |
185 | } |
186 | |
187 | static int GUS_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len) |
188 | { |
189 | GUSState *s = opaque; |
190 | IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma); |
191 | char tmpbuf[4096]; |
192 | int pos = dma_pos, mode, left = dma_len - dma_pos; |
193 | |
194 | ldebug ("read DMA %#x %d\n" , dma_pos, dma_len); |
195 | mode = k->has_autoinitialization(s->isa_dma, s->emu.gusdma); |
196 | while (left) { |
197 | int to_copy = MIN ((size_t) left, sizeof (tmpbuf)); |
198 | int copied; |
199 | |
200 | ldebug ("left=%d to_copy=%d pos=%d\n" , left, to_copy, pos); |
201 | copied = k->read_memory(s->isa_dma, nchan, tmpbuf, pos, to_copy); |
202 | gus_dma_transferdata (&s->emu, tmpbuf, copied, left == copied); |
203 | left -= copied; |
204 | pos += copied; |
205 | } |
206 | |
207 | if (((mode >> 4) & 1) == 0) { |
208 | k->release_DREQ(s->isa_dma, s->emu.gusdma); |
209 | } |
210 | return dma_len; |
211 | } |
212 | |
213 | static const VMStateDescription vmstate_gus = { |
214 | .name = "gus" , |
215 | .version_id = 2, |
216 | .minimum_version_id = 2, |
217 | .fields = (VMStateField[]) { |
218 | VMSTATE_INT32 (pos, GUSState), |
219 | VMSTATE_INT32 (left, GUSState), |
220 | VMSTATE_INT32 (shift, GUSState), |
221 | VMSTATE_INT32 (irqs, GUSState), |
222 | VMSTATE_INT32 (samples, GUSState), |
223 | VMSTATE_INT64 (last_ticks, GUSState), |
224 | VMSTATE_BUFFER (himem, GUSState), |
225 | VMSTATE_END_OF_LIST () |
226 | } |
227 | }; |
228 | |
229 | static const MemoryRegionPortio gus_portio_list1[] = { |
230 | {0x000, 1, 1, .write = gus_writeb }, |
231 | {0x006, 10, 1, .read = gus_readb, .write = gus_writeb }, |
232 | {0x100, 8, 1, .read = gus_readb, .write = gus_writeb }, |
233 | PORTIO_END_OF_LIST (), |
234 | }; |
235 | |
236 | static const MemoryRegionPortio gus_portio_list2[] = { |
237 | {0, 2, 1, .read = gus_readb }, |
238 | PORTIO_END_OF_LIST (), |
239 | }; |
240 | |
241 | static void gus_realizefn (DeviceState *dev, Error **errp) |
242 | { |
243 | ISADevice *d = ISA_DEVICE(dev); |
244 | GUSState *s = GUS (dev); |
245 | IsaDmaClass *k; |
246 | struct audsettings as; |
247 | |
248 | s->isa_dma = isa_get_dma(isa_bus_from_device(d), s->emu.gusdma); |
249 | if (!s->isa_dma) { |
250 | error_setg(errp, "ISA controller does not support DMA" ); |
251 | return; |
252 | } |
253 | |
254 | AUD_register_card ("gus" , &s->card); |
255 | |
256 | as.freq = s->freq; |
257 | as.nchannels = 2; |
258 | as.fmt = AUDIO_FORMAT_S16; |
259 | as.endianness = GUS_ENDIANNESS; |
260 | |
261 | s->voice = AUD_open_out ( |
262 | &s->card, |
263 | NULL, |
264 | "gus" , |
265 | s, |
266 | GUS_callback, |
267 | &as |
268 | ); |
269 | |
270 | if (!s->voice) { |
271 | AUD_remove_card (&s->card); |
272 | error_setg(errp, "No voice" ); |
273 | return; |
274 | } |
275 | |
276 | s->shift = 2; |
277 | s->samples = AUD_get_buffer_size_out (s->voice) >> s->shift; |
278 | s->mixbuf = g_malloc0 (s->samples << s->shift); |
279 | |
280 | isa_register_portio_list(d, &s->portio_list1, s->port, |
281 | gus_portio_list1, s, "gus" ); |
282 | isa_register_portio_list(d, &s->portio_list2, (s->port + 0x100) & 0xf00, |
283 | gus_portio_list2, s, "gus" ); |
284 | |
285 | k = ISADMA_GET_CLASS(s->isa_dma); |
286 | k->register_channel(s->isa_dma, s->emu.gusdma, GUS_read_DMA, s); |
287 | s->emu.himemaddr = s->himem; |
288 | s->emu.gusdatapos = s->emu.himemaddr + 1024 * 1024 + 32; |
289 | s->emu.opaque = s; |
290 | isa_init_irq (d, &s->pic, s->emu.gusirq); |
291 | |
292 | AUD_set_active_out (s->voice, 1); |
293 | } |
294 | |
295 | static int GUS_init (ISABus *bus) |
296 | { |
297 | isa_create_simple (bus, TYPE_GUS); |
298 | return 0; |
299 | } |
300 | |
301 | static Property gus_properties[] = { |
302 | DEFINE_AUDIO_PROPERTIES(GUSState, card), |
303 | DEFINE_PROP_UINT32 ("freq" , GUSState, freq, 44100), |
304 | DEFINE_PROP_UINT32 ("iobase" , GUSState, port, 0x240), |
305 | DEFINE_PROP_UINT32 ("irq" , GUSState, emu.gusirq, 7), |
306 | DEFINE_PROP_UINT32 ("dma" , GUSState, emu.gusdma, 3), |
307 | DEFINE_PROP_END_OF_LIST (), |
308 | }; |
309 | |
310 | static void gus_class_initfn (ObjectClass *klass, void *data) |
311 | { |
312 | DeviceClass *dc = DEVICE_CLASS (klass); |
313 | |
314 | dc->realize = gus_realizefn; |
315 | set_bit(DEVICE_CATEGORY_SOUND, dc->categories); |
316 | dc->desc = "Gravis Ultrasound GF1" ; |
317 | dc->vmsd = &vmstate_gus; |
318 | dc->props = gus_properties; |
319 | } |
320 | |
321 | static const TypeInfo gus_info = { |
322 | .name = TYPE_GUS, |
323 | .parent = TYPE_ISA_DEVICE, |
324 | .instance_size = sizeof (GUSState), |
325 | .class_init = gus_class_initfn, |
326 | }; |
327 | |
328 | static void gus_register_types (void) |
329 | { |
330 | type_register_static (&gus_info); |
331 | isa_register_soundhw("gus" , "Gravis Ultrasound GF1" , GUS_init); |
332 | } |
333 | |
334 | type_init (gus_register_types) |
335 | |