1 /* 2 * QEMU Proxy for OPL2/3 emulation by MAME team 3 * 4 * Copyright (c) 2004-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 "hw/hw.h" 27 #include "hw/audio/audio.h" 28 #include "audio/audio.h" 29 #include "hw/isa/isa.h" 30 31 //#define DEBUG 32 33 #define ADLIB_KILL_TIMERS 1 34 35 #ifdef HAS_YMF262 36 #define ADLIB_DESC "Yamaha YMF262 (OPL3)" 37 #else 38 #define ADLIB_DESC "Yamaha YM3812 (OPL2)" 39 #endif 40 41 #ifdef DEBUG 42 #include "qemu/timer.h" 43 #endif 44 45 #define dolog(...) AUD_log ("adlib", __VA_ARGS__) 46 #ifdef DEBUG 47 #define ldebug(...) dolog (__VA_ARGS__) 48 #else 49 #define ldebug(...) 50 #endif 51 52 #ifdef HAS_YMF262 53 #include "ymf262.h" 54 void YMF262UpdateOneQEMU (int which, INT16 *dst, int length); 55 #define SHIFT 2 56 #else 57 #include "fmopl.h" 58 #define SHIFT 1 59 #endif 60 61 #define TYPE_ADLIB "adlib" 62 #define ADLIB(obj) OBJECT_CHECK(AdlibState, (obj), TYPE_ADLIB) 63 64 typedef struct { 65 ISADevice parent_obj; 66 67 QEMUSoundCard card; 68 uint32_t freq; 69 uint32_t port; 70 int ticking[2]; 71 int enabled; 72 int active; 73 int bufpos; 74 #ifdef DEBUG 75 int64_t exp[2]; 76 #endif 77 int16_t *mixbuf; 78 uint64_t dexp[2]; 79 SWVoiceOut *voice; 80 int left, pos, samples; 81 QEMUAudioTimeStamp ats; 82 #ifndef HAS_YMF262 83 FM_OPL *opl; 84 #endif 85 PortioList port_list; 86 } AdlibState; 87 88 static AdlibState *glob_adlib; 89 90 static void adlib_stop_opl_timer (AdlibState *s, size_t n) 91 { 92 #ifdef HAS_YMF262 93 YMF262TimerOver (0, n); 94 #else 95 OPLTimerOver (s->opl, n); 96 #endif 97 s->ticking[n] = 0; 98 } 99 100 static void adlib_kill_timers (AdlibState *s) 101 { 102 size_t i; 103 104 for (i = 0; i < 2; ++i) { 105 if (s->ticking[i]) { 106 uint64_t delta; 107 108 delta = AUD_get_elapsed_usec_out (s->voice, &s->ats); 109 ldebug ( 110 "delta = %f dexp = %f expired => %d\n", 111 delta / 1000000.0, 112 s->dexp[i] / 1000000.0, 113 delta >= s->dexp[i] 114 ); 115 if (ADLIB_KILL_TIMERS || delta >= s->dexp[i]) { 116 adlib_stop_opl_timer (s, i); 117 AUD_init_time_stamp_out (s->voice, &s->ats); 118 } 119 } 120 } 121 } 122 123 static void adlib_write(void *opaque, uint32_t nport, uint32_t val) 124 { 125 AdlibState *s = opaque; 126 int a = nport & 3; 127 128 s->active = 1; 129 AUD_set_active_out (s->voice, 1); 130 131 adlib_kill_timers (s); 132 133 #ifdef HAS_YMF262 134 YMF262Write (0, a, val); 135 #else 136 OPLWrite (s->opl, a, val); 137 #endif 138 } 139 140 static uint32_t adlib_read(void *opaque, uint32_t nport) 141 { 142 AdlibState *s = opaque; 143 uint8_t data; 144 int a = nport & 3; 145 146 adlib_kill_timers (s); 147 148 #ifdef HAS_YMF262 149 data = YMF262Read (0, a); 150 #else 151 data = OPLRead (s->opl, a); 152 #endif 153 return data; 154 } 155 156 static void timer_handler (int c, double interval_Sec) 157 { 158 AdlibState *s = glob_adlib; 159 unsigned n = c & 1; 160 #ifdef DEBUG 161 double interval; 162 int64_t exp; 163 #endif 164 165 if (interval_Sec == 0.0) { 166 s->ticking[n] = 0; 167 return; 168 } 169 170 s->ticking[n] = 1; 171 #ifdef DEBUG 172 interval = get_ticks_per_sec () * interval_Sec; 173 exp = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + interval; 174 s->exp[n] = exp; 175 #endif 176 177 s->dexp[n] = interval_Sec * 1000000.0; 178 AUD_init_time_stamp_out (s->voice, &s->ats); 179 } 180 181 static int write_audio (AdlibState *s, int samples) 182 { 183 int net = 0; 184 int pos = s->pos; 185 186 while (samples) { 187 int nbytes, wbytes, wsampl; 188 189 nbytes = samples << SHIFT; 190 wbytes = AUD_write ( 191 s->voice, 192 s->mixbuf + (pos << (SHIFT - 1)), 193 nbytes 194 ); 195 196 if (wbytes) { 197 wsampl = wbytes >> SHIFT; 198 199 samples -= wsampl; 200 pos = (pos + wsampl) % s->samples; 201 202 net += wsampl; 203 } 204 else { 205 break; 206 } 207 } 208 209 return net; 210 } 211 212 static void adlib_callback (void *opaque, int free) 213 { 214 AdlibState *s = opaque; 215 int samples, net = 0, to_play, written; 216 217 samples = free >> SHIFT; 218 if (!(s->active && s->enabled) || !samples) { 219 return; 220 } 221 222 to_play = audio_MIN (s->left, samples); 223 while (to_play) { 224 written = write_audio (s, to_play); 225 226 if (written) { 227 s->left -= written; 228 samples -= written; 229 to_play -= written; 230 s->pos = (s->pos + written) % s->samples; 231 } 232 else { 233 return; 234 } 235 } 236 237 samples = audio_MIN (samples, s->samples - s->pos); 238 if (!samples) { 239 return; 240 } 241 242 #ifdef HAS_YMF262 243 YMF262UpdateOneQEMU (0, s->mixbuf + s->pos * 2, samples); 244 #else 245 YM3812UpdateOne (s->opl, s->mixbuf + s->pos, samples); 246 #endif 247 248 while (samples) { 249 written = write_audio (s, samples); 250 251 if (written) { 252 net += written; 253 samples -= written; 254 s->pos = (s->pos + written) % s->samples; 255 } 256 else { 257 s->left = samples; 258 return; 259 } 260 } 261 } 262 263 static void Adlib_fini (AdlibState *s) 264 { 265 #ifdef HAS_YMF262 266 YMF262Shutdown (); 267 #else 268 if (s->opl) { 269 OPLDestroy (s->opl); 270 s->opl = NULL; 271 } 272 #endif 273 274 g_free(s->mixbuf); 275 276 s->active = 0; 277 s->enabled = 0; 278 AUD_remove_card (&s->card); 279 } 280 281 static MemoryRegionPortio adlib_portio_list[] = { 282 { 0, 4, 1, .read = adlib_read, .write = adlib_write, }, 283 { 0, 2, 1, .read = adlib_read, .write = adlib_write, }, 284 { 0x388, 4, 1, .read = adlib_read, .write = adlib_write, }, 285 PORTIO_END_OF_LIST(), 286 }; 287 288 static void adlib_realizefn (DeviceState *dev, Error **errp) 289 { 290 AdlibState *s = ADLIB(dev); 291 struct audsettings as; 292 293 if (glob_adlib) { 294 error_setg (errp, "Cannot create more than 1 adlib device"); 295 return; 296 } 297 glob_adlib = s; 298 299 #ifdef HAS_YMF262 300 if (YMF262Init (1, 14318180, s->freq)) { 301 error_setg (errp, "YMF262Init %d failed", s->freq); 302 return; 303 } 304 else { 305 YMF262SetTimerHandler (0, timer_handler, 0); 306 s->enabled = 1; 307 } 308 #else 309 s->opl = OPLCreate (OPL_TYPE_YM3812, 3579545, s->freq); 310 if (!s->opl) { 311 error_setg (errp, "OPLCreate %d failed", s->freq); 312 return; 313 } 314 else { 315 OPLSetTimerHandler (s->opl, timer_handler, 0); 316 s->enabled = 1; 317 } 318 #endif 319 320 as.freq = s->freq; 321 as.nchannels = SHIFT; 322 as.fmt = AUD_FMT_S16; 323 as.endianness = AUDIO_HOST_ENDIANNESS; 324 325 AUD_register_card ("adlib", &s->card); 326 327 s->voice = AUD_open_out ( 328 &s->card, 329 s->voice, 330 "adlib", 331 s, 332 adlib_callback, 333 &as 334 ); 335 if (!s->voice) { 336 Adlib_fini (s); 337 error_setg (errp, "Initializing audio voice failed"); 338 return; 339 } 340 341 s->samples = AUD_get_buffer_size_out (s->voice) >> SHIFT; 342 s->mixbuf = g_malloc0 (s->samples << SHIFT); 343 344 adlib_portio_list[0].offset = s->port; 345 adlib_portio_list[1].offset = s->port + 8; 346 portio_list_init (&s->port_list, OBJECT(s), adlib_portio_list, s, "adlib"); 347 portio_list_add (&s->port_list, isa_address_space_io(&s->parent_obj), 0); 348 } 349 350 static Property adlib_properties[] = { 351 DEFINE_PROP_UINT32 ("iobase", AdlibState, port, 0x220), 352 DEFINE_PROP_UINT32 ("freq", AdlibState, freq, 44100), 353 DEFINE_PROP_END_OF_LIST (), 354 }; 355 356 static void adlib_class_initfn (ObjectClass *klass, void *data) 357 { 358 DeviceClass *dc = DEVICE_CLASS (klass); 359 360 dc->realize = adlib_realizefn; 361 set_bit(DEVICE_CATEGORY_SOUND, dc->categories); 362 dc->desc = ADLIB_DESC; 363 dc->props = adlib_properties; 364 } 365 366 static const TypeInfo adlib_info = { 367 .name = TYPE_ADLIB, 368 .parent = TYPE_ISA_DEVICE, 369 .instance_size = sizeof (AdlibState), 370 .class_init = adlib_class_initfn, 371 }; 372 373 static int Adlib_init (ISABus *bus) 374 { 375 isa_create_simple (bus, TYPE_ADLIB); 376 return 0; 377 } 378 379 static void adlib_register_types (void) 380 { 381 type_register_static (&adlib_info); 382 isa_register_soundhw("adlib", ADLIB_DESC, Adlib_init); 383 } 384 385 type_init (adlib_register_types) 386