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 #include "qom/object.h" 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 45 #define TYPE_GUS "gus" 46 typedef struct GUSState GUSState; 47 DECLARE_INSTANCE_CHECKER(GUSState, GUS, 48 TYPE_GUS) 49 50 struct GUSState { 51 ISADevice dev; 52 GUSEmuState emu; 53 QEMUSoundCard card; 54 uint32_t freq; 55 uint32_t port; 56 int pos, left, shift, irqs; 57 int16_t *mixbuf; 58 uint8_t himem[1024 * 1024 + 32 + 4096]; 59 int samples; 60 SWVoiceOut *voice; 61 int64_t last_ticks; 62 qemu_irq pic; 63 IsaDma *isa_dma; 64 PortioList portio_list1; 65 PortioList portio_list2; 66 }; 67 68 static uint32_t gus_readb(void *opaque, uint32_t nport) 69 { 70 GUSState *s = opaque; 71 72 return gus_read (&s->emu, nport, 1); 73 } 74 75 static void gus_writeb(void *opaque, uint32_t nport, uint32_t val) 76 { 77 GUSState *s = opaque; 78 79 gus_write (&s->emu, nport, 1, val); 80 } 81 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; 119 to_play = MIN (samples, s->left); 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 134 samples = MIN (samples, s->samples); 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 149 reset: 150 gus_irqgen (&s->emu, (uint64_t)net * 1000000 / s->freq); 151 } 152 153 int GUS_irqrequest (GUSEmuState *emu, int hwirq, int n) 154 { 155 GUSState *s = emu->opaque; 156 /* qemu_irq_lower (s->pic); */ 157 qemu_irq_raise (s->pic); 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); 167 qemu_irq_lower (s->pic); 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 176 void GUS_dmarequest (GUSEmuState *emu) 177 { 178 GUSState *s = emu->opaque; 179 IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma); 180 ldebug ("dma request %d\n", der->gusdma); 181 k->hold_DREQ(s->isa_dma, s->emu.gusdma); 182 } 183 184 static int GUS_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len) 185 { 186 GUSState *s = opaque; 187 IsaDmaClass *k = ISADMA_GET_CLASS(s->isa_dma); 188 char tmpbuf[4096]; 189 int pos = dma_pos, mode, left = dma_len - dma_pos; 190 191 ldebug ("read DMA %#x %d\n", dma_pos, dma_len); 192 mode = k->has_autoinitialization(s->isa_dma, s->emu.gusdma); 193 while (left) { 194 int to_copy = MIN ((size_t) left, sizeof (tmpbuf)); 195 int copied; 196 197 ldebug ("left=%d to_copy=%d pos=%d\n", left, to_copy, pos); 198 copied = k->read_memory(s->isa_dma, nchan, tmpbuf, pos, to_copy); 199 gus_dma_transferdata (&s->emu, tmpbuf, copied, left == copied); 200 left -= copied; 201 pos += copied; 202 } 203 204 if (((mode >> 4) & 1) == 0) { 205 k->release_DREQ(s->isa_dma, s->emu.gusdma); 206 } 207 return dma_len; 208 } 209 210 static const VMStateDescription vmstate_gus = { 211 .name = "gus", 212 .version_id = 2, 213 .minimum_version_id = 2, 214 .fields = (VMStateField[]) { 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 () 223 } 224 }; 225 226 static const MemoryRegionPortio gus_portio_list1[] = { 227 {0x000, 1, 1, .write = gus_writeb }, 228 {0x006, 10, 1, .read = gus_readb, .write = gus_writeb }, 229 {0x100, 8, 1, .read = gus_readb, .write = gus_writeb }, 230 PORTIO_END_OF_LIST (), 231 }; 232 233 static const MemoryRegionPortio gus_portio_list2[] = { 234 {0, 2, 1, .read = gus_readb }, 235 PORTIO_END_OF_LIST (), 236 }; 237 238 static void gus_realizefn (DeviceState *dev, Error **errp) 239 { 240 ISADevice *d = ISA_DEVICE(dev); 241 GUSState *s = GUS (dev); 242 IsaDmaClass *k; 243 struct audsettings as; 244 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 251 AUD_register_card ("gus", &s->card); 252 253 as.freq = s->freq; 254 as.nchannels = 2; 255 as.fmt = AUDIO_FORMAT_S16; 256 as.endianness = AUDIO_HOST_ENDIANNESS; 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); 269 error_setg(errp, "No voice"); 270 return; 271 } 272 273 s->shift = 2; 274 s->samples = AUD_get_buffer_size_out (s->voice) >> s->shift; 275 s->mixbuf = g_malloc0 (s->samples << s->shift); 276 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"); 281 282 k = ISADMA_GET_CLASS(s->isa_dma); 283 k->register_channel(s->isa_dma, s->emu.gusdma, GUS_read_DMA, s); 284 s->emu.himemaddr = s->himem; 285 s->emu.gusdatapos = s->emu.himemaddr + 1024 * 1024 + 32; 286 s->emu.opaque = s; 287 isa_init_irq (d, &s->pic, s->emu.gusirq); 288 289 AUD_set_active_out (s->voice, 1); 290 } 291 292 static Property gus_properties[] = { 293 DEFINE_AUDIO_PROPERTIES(GUSState, card), 294 DEFINE_PROP_UINT32 ("freq", GUSState, freq, 44100), 295 DEFINE_PROP_UINT32 ("iobase", GUSState, port, 0x240), 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 301 static void gus_class_initfn (ObjectClass *klass, void *data) 302 { 303 DeviceClass *dc = DEVICE_CLASS (klass); 304 305 dc->realize = gus_realizefn; 306 set_bit(DEVICE_CATEGORY_SOUND, dc->categories); 307 dc->desc = "Gravis Ultrasound GF1"; 308 dc->vmsd = &vmstate_gus; 309 device_class_set_props(dc, gus_properties); 310 } 311 312 static const TypeInfo gus_info = { 313 .name = TYPE_GUS, 314 .parent = TYPE_ISA_DEVICE, 315 .instance_size = sizeof (GUSState), 316 .class_init = gus_class_initfn, 317 }; 318 319 static void gus_register_types (void) 320 { 321 type_register_static (&gus_info); 322 deprecated_register_soundhw("gus", "Gravis Ultrasound GF1", 1, TYPE_GUS); 323 } 324 325 type_init (gus_register_types) 326