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