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