1 /* 2 * QEMU Soundblaster 16 emulation 3 * 4 * Copyright (c) 2003-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/audio/soundhw.h" 27 #include "audio/audio.h" 28 #include "hw/irq.h" 29 #include "hw/isa/isa.h" 30 #include "hw/qdev-properties.h" 31 #include "migration/vmstate.h" 32 #include "qemu/timer.h" 33 #include "qemu/host-utils.h" 34 #include "qemu/log.h" 35 #include "qemu/module.h" 36 #include "qapi/error.h" 37 #include "qom/object.h" 38 39 #define dolog(...) AUD_log ("sb16", __VA_ARGS__) 40 41 /* #define DEBUG */ 42 /* #define DEBUG_SB16_MOST */ 43 44 #ifdef DEBUG 45 #define ldebug(...) dolog (__VA_ARGS__) 46 #else 47 #define ldebug(...) 48 #endif 49 50 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992."; 51 52 #define TYPE_SB16 "sb16" 53 typedef struct SB16State SB16State; 54 #define SB16(obj) OBJECT_CHECK (SB16State, (obj), TYPE_SB16) 55 56 struct SB16State { 57 ISADevice parent_obj; 58 59 QEMUSoundCard card; 60 qemu_irq pic; 61 uint32_t irq; 62 uint32_t dma; 63 uint32_t hdma; 64 uint32_t port; 65 uint32_t ver; 66 IsaDma *isa_dma; 67 IsaDma *isa_hdma; 68 69 int in_index; 70 int out_data_len; 71 int fmt_stereo; 72 int fmt_signed; 73 int fmt_bits; 74 AudioFormat fmt; 75 int dma_auto; 76 int block_size; 77 int fifo; 78 int freq; 79 int time_const; 80 int speaker; 81 int needed_bytes; 82 int cmd; 83 int use_hdma; 84 int highspeed; 85 int can_write; 86 87 int v2x6; 88 89 uint8_t csp_param; 90 uint8_t csp_value; 91 uint8_t csp_mode; 92 uint8_t csp_regs[256]; 93 uint8_t csp_index; 94 uint8_t csp_reg83[4]; 95 int csp_reg83r; 96 int csp_reg83w; 97 98 uint8_t in2_data[10]; 99 uint8_t out_data[50]; 100 uint8_t test_reg; 101 uint8_t last_read_byte; 102 int nzero; 103 104 int left_till_irq; 105 106 int dma_running; 107 int bytes_per_second; 108 int align; 109 int audio_free; 110 SWVoiceOut *voice; 111 112 QEMUTimer *aux_ts; 113 /* mixer state */ 114 int mixer_nreg; 115 uint8_t mixer_regs[256]; 116 PortioList portio_list; 117 }; 118 119 static void SB_audio_callback (void *opaque, int free); 120 121 static int magic_of_irq (int irq) 122 { 123 switch (irq) { 124 case 5: 125 return 2; 126 case 7: 127 return 4; 128 case 9: 129 return 1; 130 case 10: 131 return 8; 132 default: 133 qemu_log_mask(LOG_GUEST_ERROR, "bad irq %d\n", irq); 134 return 2; 135 } 136 } 137 138 static int irq_of_magic (int magic) 139 { 140 switch (magic) { 141 case 1: 142 return 9; 143 case 2: 144 return 5; 145 case 4: 146 return 7; 147 case 8: 148 return 10; 149 default: 150 qemu_log_mask(LOG_GUEST_ERROR, "bad irq magic %d\n", magic); 151 return -1; 152 } 153 } 154 155 #if 0 156 static void log_dsp (SB16State *dsp) 157 { 158 ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n", 159 dsp->fmt_stereo ? "Stereo" : "Mono", 160 dsp->fmt_signed ? "Signed" : "Unsigned", 161 dsp->fmt_bits, 162 dsp->dma_auto ? "Auto" : "Single", 163 dsp->block_size, 164 dsp->freq, 165 dsp->time_const, 166 dsp->speaker); 167 } 168 #endif 169 170 static void speaker (SB16State *s, int on) 171 { 172 s->speaker = on; 173 /* AUD_enable (s->voice, on); */ 174 } 175 176 static void control (SB16State *s, int hold) 177 { 178 int dma = s->use_hdma ? s->hdma : s->dma; 179 IsaDma *isa_dma = s->use_hdma ? s->isa_hdma : s->isa_dma; 180 IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma); 181 s->dma_running = hold; 182 183 ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma); 184 185 if (hold) { 186 k->hold_DREQ(isa_dma, dma); 187 AUD_set_active_out (s->voice, 1); 188 } 189 else { 190 k->release_DREQ(isa_dma, dma); 191 AUD_set_active_out (s->voice, 0); 192 } 193 } 194 195 static void aux_timer (void *opaque) 196 { 197 SB16State *s = opaque; 198 s->can_write = 1; 199 qemu_irq_raise (s->pic); 200 } 201 202 #define DMA8_AUTO 1 203 #define DMA8_HIGH 2 204 205 static void continue_dma8 (SB16State *s) 206 { 207 if (s->freq > 0) { 208 struct audsettings as; 209 210 s->audio_free = 0; 211 212 as.freq = s->freq; 213 as.nchannels = 1 << s->fmt_stereo; 214 as.fmt = s->fmt; 215 as.endianness = 0; 216 217 s->voice = AUD_open_out ( 218 &s->card, 219 s->voice, 220 "sb16", 221 s, 222 SB_audio_callback, 223 &as 224 ); 225 } 226 227 control (s, 1); 228 } 229 230 static void dma_cmd8 (SB16State *s, int mask, int dma_len) 231 { 232 s->fmt = AUDIO_FORMAT_U8; 233 s->use_hdma = 0; 234 s->fmt_bits = 8; 235 s->fmt_signed = 0; 236 s->fmt_stereo = (s->mixer_regs[0x0e] & 2) != 0; 237 if (-1 == s->time_const) { 238 if (s->freq <= 0) 239 s->freq = 11025; 240 } 241 else { 242 int tmp = (256 - s->time_const); 243 s->freq = (1000000 + (tmp / 2)) / tmp; 244 } 245 246 if (dma_len != -1) { 247 s->block_size = dma_len << s->fmt_stereo; 248 } 249 else { 250 /* This is apparently the only way to make both Act1/PL 251 and SecondReality/FC work 252 253 Act1 sets block size via command 0x48 and it's an odd number 254 SR does the same with even number 255 Both use stereo, and Creatives own documentation states that 256 0x48 sets block size in bytes less one.. go figure */ 257 s->block_size &= ~s->fmt_stereo; 258 } 259 260 s->freq >>= s->fmt_stereo; 261 s->left_till_irq = s->block_size; 262 s->bytes_per_second = (s->freq << s->fmt_stereo); 263 /* s->highspeed = (mask & DMA8_HIGH) != 0; */ 264 s->dma_auto = (mask & DMA8_AUTO) != 0; 265 s->align = (1 << s->fmt_stereo) - 1; 266 267 if (s->block_size & s->align) { 268 qemu_log_mask(LOG_GUEST_ERROR, "warning: misaligned block size %d," 269 " alignment %d\n", s->block_size, s->align + 1); 270 } 271 272 ldebug ("freq %d, stereo %d, sign %d, bits %d, " 273 "dma %d, auto %d, fifo %d, high %d\n", 274 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits, 275 s->block_size, s->dma_auto, s->fifo, s->highspeed); 276 277 continue_dma8 (s); 278 speaker (s, 1); 279 } 280 281 static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len) 282 { 283 s->use_hdma = cmd < 0xc0; 284 s->fifo = (cmd >> 1) & 1; 285 s->dma_auto = (cmd >> 2) & 1; 286 s->fmt_signed = (d0 >> 4) & 1; 287 s->fmt_stereo = (d0 >> 5) & 1; 288 289 switch (cmd >> 4) { 290 case 11: 291 s->fmt_bits = 16; 292 break; 293 294 case 12: 295 s->fmt_bits = 8; 296 break; 297 } 298 299 if (-1 != s->time_const) { 300 #if 1 301 int tmp = 256 - s->time_const; 302 s->freq = (1000000 + (tmp / 2)) / tmp; 303 #else 304 /* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */ 305 s->freq = 1000000 / ((255 - s->time_const)); 306 #endif 307 s->time_const = -1; 308 } 309 310 s->block_size = dma_len + 1; 311 s->block_size <<= (s->fmt_bits == 16); 312 if (!s->dma_auto) { 313 /* It is clear that for DOOM and auto-init this value 314 shouldn't take stereo into account, while Miles Sound Systems 315 setsound.exe with single transfer mode wouldn't work without it 316 wonders of SB16 yet again */ 317 s->block_size <<= s->fmt_stereo; 318 } 319 320 ldebug ("freq %d, stereo %d, sign %d, bits %d, " 321 "dma %d, auto %d, fifo %d, high %d\n", 322 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits, 323 s->block_size, s->dma_auto, s->fifo, s->highspeed); 324 325 if (16 == s->fmt_bits) { 326 if (s->fmt_signed) { 327 s->fmt = AUDIO_FORMAT_S16; 328 } 329 else { 330 s->fmt = AUDIO_FORMAT_U16; 331 } 332 } 333 else { 334 if (s->fmt_signed) { 335 s->fmt = AUDIO_FORMAT_S8; 336 } 337 else { 338 s->fmt = AUDIO_FORMAT_U8; 339 } 340 } 341 342 s->left_till_irq = s->block_size; 343 344 s->bytes_per_second = (s->freq << s->fmt_stereo) << (s->fmt_bits == 16); 345 s->highspeed = 0; 346 s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1; 347 if (s->block_size & s->align) { 348 qemu_log_mask(LOG_GUEST_ERROR, "warning: misaligned block size %d," 349 " alignment %d\n", s->block_size, s->align + 1); 350 } 351 352 if (s->freq) { 353 struct audsettings as; 354 355 s->audio_free = 0; 356 357 as.freq = s->freq; 358 as.nchannels = 1 << s->fmt_stereo; 359 as.fmt = s->fmt; 360 as.endianness = 0; 361 362 s->voice = AUD_open_out ( 363 &s->card, 364 s->voice, 365 "sb16", 366 s, 367 SB_audio_callback, 368 &as 369 ); 370 } 371 372 control (s, 1); 373 speaker (s, 1); 374 } 375 376 static inline void dsp_out_data (SB16State *s, uint8_t val) 377 { 378 ldebug ("outdata %#x\n", val); 379 if ((size_t) s->out_data_len < sizeof (s->out_data)) { 380 s->out_data[s->out_data_len++] = val; 381 } 382 } 383 384 static inline uint8_t dsp_get_data (SB16State *s) 385 { 386 if (s->in_index) { 387 return s->in2_data[--s->in_index]; 388 } 389 else { 390 dolog ("buffer underflow\n"); 391 return 0; 392 } 393 } 394 395 static void command (SB16State *s, uint8_t cmd) 396 { 397 ldebug ("command %#x\n", cmd); 398 399 if (cmd > 0xaf && cmd < 0xd0) { 400 if (cmd & 8) { 401 qemu_log_mask(LOG_UNIMP, "ADC not yet supported (command %#x)\n", 402 cmd); 403 } 404 405 switch (cmd >> 4) { 406 case 11: 407 case 12: 408 break; 409 default: 410 qemu_log_mask(LOG_GUEST_ERROR, "%#x wrong bits\n", cmd); 411 } 412 s->needed_bytes = 3; 413 } 414 else { 415 s->needed_bytes = 0; 416 417 switch (cmd) { 418 case 0x03: 419 dsp_out_data (s, 0x10); /* s->csp_param); */ 420 goto warn; 421 422 case 0x04: 423 s->needed_bytes = 1; 424 goto warn; 425 426 case 0x05: 427 s->needed_bytes = 2; 428 goto warn; 429 430 case 0x08: 431 /* __asm__ ("int3"); */ 432 goto warn; 433 434 case 0x0e: 435 s->needed_bytes = 2; 436 goto warn; 437 438 case 0x09: 439 dsp_out_data (s, 0xf8); 440 goto warn; 441 442 case 0x0f: 443 s->needed_bytes = 1; 444 goto warn; 445 446 case 0x10: 447 s->needed_bytes = 1; 448 goto warn; 449 450 case 0x14: 451 s->needed_bytes = 2; 452 s->block_size = 0; 453 break; 454 455 case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */ 456 dma_cmd8 (s, DMA8_AUTO, -1); 457 break; 458 459 case 0x20: /* Direct ADC, Juice/PL */ 460 dsp_out_data (s, 0xff); 461 goto warn; 462 463 case 0x35: 464 qemu_log_mask(LOG_UNIMP, "0x35 - MIDI command not implemented\n"); 465 break; 466 467 case 0x40: 468 s->freq = -1; 469 s->time_const = -1; 470 s->needed_bytes = 1; 471 break; 472 473 case 0x41: 474 s->freq = -1; 475 s->time_const = -1; 476 s->needed_bytes = 2; 477 break; 478 479 case 0x42: 480 s->freq = -1; 481 s->time_const = -1; 482 s->needed_bytes = 2; 483 goto warn; 484 485 case 0x45: 486 dsp_out_data (s, 0xaa); 487 goto warn; 488 489 case 0x47: /* Continue Auto-Initialize DMA 16bit */ 490 break; 491 492 case 0x48: 493 s->needed_bytes = 2; 494 break; 495 496 case 0x74: 497 s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */ 498 qemu_log_mask(LOG_UNIMP, "0x75 - DMA DAC, 4-bit ADPCM not" 499 " implemented\n"); 500 break; 501 502 case 0x75: /* DMA DAC, 4-bit ADPCM Reference */ 503 s->needed_bytes = 2; 504 qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 4-bit ADPCM Reference not" 505 " implemented\n"); 506 break; 507 508 case 0x76: /* DMA DAC, 2.6-bit ADPCM */ 509 s->needed_bytes = 2; 510 qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 2.6-bit ADPCM not" 511 " implemented\n"); 512 break; 513 514 case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */ 515 s->needed_bytes = 2; 516 qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 2.6-bit ADPCM Reference" 517 " not implemented\n"); 518 break; 519 520 case 0x7d: 521 qemu_log_mask(LOG_UNIMP, "0x7d - Autio-Initialize DMA DAC, 4-bit" 522 " ADPCM Reference\n"); 523 qemu_log_mask(LOG_UNIMP, "not implemented\n"); 524 break; 525 526 case 0x7f: 527 qemu_log_mask(LOG_UNIMP, "0x7d - Autio-Initialize DMA DAC, 2.6-bit" 528 " ADPCM Reference\n"); 529 qemu_log_mask(LOG_UNIMP, "not implemented\n"); 530 break; 531 532 case 0x80: 533 s->needed_bytes = 2; 534 break; 535 536 case 0x90: 537 case 0x91: 538 dma_cmd8 (s, ((cmd & 1) == 0) | DMA8_HIGH, -1); 539 break; 540 541 case 0xd0: /* halt DMA operation. 8bit */ 542 control (s, 0); 543 break; 544 545 case 0xd1: /* speaker on */ 546 speaker (s, 1); 547 break; 548 549 case 0xd3: /* speaker off */ 550 speaker (s, 0); 551 break; 552 553 case 0xd4: /* continue DMA operation. 8bit */ 554 /* KQ6 (or maybe Sierras audblst.drv in general) resets 555 the frequency between halt/continue */ 556 continue_dma8 (s); 557 break; 558 559 case 0xd5: /* halt DMA operation. 16bit */ 560 control (s, 0); 561 break; 562 563 case 0xd6: /* continue DMA operation. 16bit */ 564 control (s, 1); 565 break; 566 567 case 0xd9: /* exit auto-init DMA after this block. 16bit */ 568 s->dma_auto = 0; 569 break; 570 571 case 0xda: /* exit auto-init DMA after this block. 8bit */ 572 s->dma_auto = 0; 573 break; 574 575 case 0xe0: /* DSP identification */ 576 s->needed_bytes = 1; 577 break; 578 579 case 0xe1: 580 dsp_out_data (s, s->ver & 0xff); 581 dsp_out_data (s, s->ver >> 8); 582 break; 583 584 case 0xe2: 585 s->needed_bytes = 1; 586 goto warn; 587 588 case 0xe3: 589 { 590 int i; 591 for (i = sizeof (e3) - 1; i >= 0; --i) 592 dsp_out_data (s, e3[i]); 593 } 594 break; 595 596 case 0xe4: /* write test reg */ 597 s->needed_bytes = 1; 598 break; 599 600 case 0xe7: 601 qemu_log_mask(LOG_UNIMP, "Attempt to probe for ESS (0xe7)?\n"); 602 break; 603 604 case 0xe8: /* read test reg */ 605 dsp_out_data (s, s->test_reg); 606 break; 607 608 case 0xf2: 609 case 0xf3: 610 dsp_out_data (s, 0xaa); 611 s->mixer_regs[0x82] |= (cmd == 0xf2) ? 1 : 2; 612 qemu_irq_raise (s->pic); 613 break; 614 615 case 0xf9: 616 s->needed_bytes = 1; 617 goto warn; 618 619 case 0xfa: 620 dsp_out_data (s, 0); 621 goto warn; 622 623 case 0xfc: /* FIXME */ 624 dsp_out_data (s, 0); 625 goto warn; 626 627 default: 628 qemu_log_mask(LOG_UNIMP, "Unrecognized command %#x\n", cmd); 629 break; 630 } 631 } 632 633 if (!s->needed_bytes) { 634 ldebug ("\n"); 635 } 636 637 exit: 638 if (!s->needed_bytes) { 639 s->cmd = -1; 640 } 641 else { 642 s->cmd = cmd; 643 } 644 return; 645 646 warn: 647 qemu_log_mask(LOG_UNIMP, "warning: command %#x,%d is not truly understood" 648 " yet\n", cmd, s->needed_bytes); 649 goto exit; 650 651 } 652 653 static uint16_t dsp_get_lohi (SB16State *s) 654 { 655 uint8_t hi = dsp_get_data (s); 656 uint8_t lo = dsp_get_data (s); 657 return (hi << 8) | lo; 658 } 659 660 static uint16_t dsp_get_hilo (SB16State *s) 661 { 662 uint8_t lo = dsp_get_data (s); 663 uint8_t hi = dsp_get_data (s); 664 return (hi << 8) | lo; 665 } 666 667 static void complete (SB16State *s) 668 { 669 int d0, d1, d2; 670 ldebug ("complete command %#x, in_index %d, needed_bytes %d\n", 671 s->cmd, s->in_index, s->needed_bytes); 672 673 if (s->cmd > 0xaf && s->cmd < 0xd0) { 674 d2 = dsp_get_data (s); 675 d1 = dsp_get_data (s); 676 d0 = dsp_get_data (s); 677 678 if (s->cmd & 8) { 679 dolog ("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", 680 s->cmd, d0, d1, d2); 681 } 682 else { 683 ldebug ("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n", 684 s->cmd, d0, d1, d2); 685 dma_cmd (s, s->cmd, d0, d1 + (d2 << 8)); 686 } 687 } 688 else { 689 switch (s->cmd) { 690 case 0x04: 691 s->csp_mode = dsp_get_data (s); 692 s->csp_reg83r = 0; 693 s->csp_reg83w = 0; 694 ldebug ("CSP command 0x04: mode=%#x\n", s->csp_mode); 695 break; 696 697 case 0x05: 698 s->csp_param = dsp_get_data (s); 699 s->csp_value = dsp_get_data (s); 700 ldebug ("CSP command 0x05: param=%#x value=%#x\n", 701 s->csp_param, 702 s->csp_value); 703 break; 704 705 case 0x0e: 706 d0 = dsp_get_data (s); 707 d1 = dsp_get_data (s); 708 ldebug ("write CSP register %d <- %#x\n", d1, d0); 709 if (d1 == 0x83) { 710 ldebug ("0x83[%d] <- %#x\n", s->csp_reg83r, d0); 711 s->csp_reg83[s->csp_reg83r % 4] = d0; 712 s->csp_reg83r += 1; 713 } 714 else { 715 s->csp_regs[d1] = d0; 716 } 717 break; 718 719 case 0x0f: 720 d0 = dsp_get_data (s); 721 ldebug ("read CSP register %#x -> %#x, mode=%#x\n", 722 d0, s->csp_regs[d0], s->csp_mode); 723 if (d0 == 0x83) { 724 ldebug ("0x83[%d] -> %#x\n", 725 s->csp_reg83w, 726 s->csp_reg83[s->csp_reg83w % 4]); 727 dsp_out_data (s, s->csp_reg83[s->csp_reg83w % 4]); 728 s->csp_reg83w += 1; 729 } 730 else { 731 dsp_out_data (s, s->csp_regs[d0]); 732 } 733 break; 734 735 case 0x10: 736 d0 = dsp_get_data (s); 737 dolog ("cmd 0x10 d0=%#x\n", d0); 738 break; 739 740 case 0x14: 741 dma_cmd8 (s, 0, dsp_get_lohi (s) + 1); 742 break; 743 744 case 0x40: 745 s->time_const = dsp_get_data (s); 746 ldebug ("set time const %d\n", s->time_const); 747 break; 748 749 case 0x41: 750 case 0x42: 751 /* 752 * 0x41 is documented as setting the output sample rate, 753 * and 0x42 the input sample rate, but in fact SB16 hardware 754 * seems to have only a single sample rate under the hood, 755 * and FT2 sets output freq with this (go figure). Compare: 756 * http://homepages.cae.wisc.edu/~brodskye/sb16doc/sb16doc.html#SamplingRate 757 */ 758 s->freq = dsp_get_hilo (s); 759 ldebug ("set freq %d\n", s->freq); 760 break; 761 762 case 0x48: 763 s->block_size = dsp_get_lohi (s) + 1; 764 ldebug ("set dma block len %d\n", s->block_size); 765 break; 766 767 case 0x74: 768 case 0x75: 769 case 0x76: 770 case 0x77: 771 /* ADPCM stuff, ignore */ 772 break; 773 774 case 0x80: 775 { 776 int freq, samples, bytes; 777 int64_t ticks; 778 779 freq = s->freq > 0 ? s->freq : 11025; 780 samples = dsp_get_lohi (s) + 1; 781 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16); 782 ticks = muldiv64(bytes, NANOSECONDS_PER_SECOND, freq); 783 if (ticks < NANOSECONDS_PER_SECOND / 1024) { 784 qemu_irq_raise (s->pic); 785 } 786 else { 787 if (s->aux_ts) { 788 timer_mod ( 789 s->aux_ts, 790 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ticks 791 ); 792 } 793 } 794 ldebug ("mix silence %d %d %" PRId64 "\n", samples, bytes, ticks); 795 } 796 break; 797 798 case 0xe0: 799 d0 = dsp_get_data (s); 800 s->out_data_len = 0; 801 ldebug ("E0 data = %#x\n", d0); 802 dsp_out_data (s, ~d0); 803 break; 804 805 case 0xe2: 806 #ifdef DEBUG 807 d0 = dsp_get_data (s); 808 dolog ("E2 = %#x\n", d0); 809 #endif 810 break; 811 812 case 0xe4: 813 s->test_reg = dsp_get_data (s); 814 break; 815 816 case 0xf9: 817 d0 = dsp_get_data (s); 818 ldebug ("command 0xf9 with %#x\n", d0); 819 switch (d0) { 820 case 0x0e: 821 dsp_out_data (s, 0xff); 822 break; 823 824 case 0x0f: 825 dsp_out_data (s, 0x07); 826 break; 827 828 case 0x37: 829 dsp_out_data (s, 0x38); 830 break; 831 832 default: 833 dsp_out_data (s, 0x00); 834 break; 835 } 836 break; 837 838 default: 839 qemu_log_mask(LOG_UNIMP, "complete: unrecognized command %#x\n", 840 s->cmd); 841 return; 842 } 843 } 844 845 ldebug ("\n"); 846 s->cmd = -1; 847 } 848 849 static void legacy_reset (SB16State *s) 850 { 851 struct audsettings as; 852 853 s->freq = 11025; 854 s->fmt_signed = 0; 855 s->fmt_bits = 8; 856 s->fmt_stereo = 0; 857 858 as.freq = s->freq; 859 as.nchannels = 1; 860 as.fmt = AUDIO_FORMAT_U8; 861 as.endianness = 0; 862 863 s->voice = AUD_open_out ( 864 &s->card, 865 s->voice, 866 "sb16", 867 s, 868 SB_audio_callback, 869 &as 870 ); 871 872 /* Not sure about that... */ 873 /* AUD_set_active_out (s->voice, 1); */ 874 } 875 876 static void reset (SB16State *s) 877 { 878 qemu_irq_lower (s->pic); 879 if (s->dma_auto) { 880 qemu_irq_raise (s->pic); 881 qemu_irq_lower (s->pic); 882 } 883 884 s->mixer_regs[0x82] = 0; 885 s->dma_auto = 0; 886 s->in_index = 0; 887 s->out_data_len = 0; 888 s->left_till_irq = 0; 889 s->needed_bytes = 0; 890 s->block_size = -1; 891 s->nzero = 0; 892 s->highspeed = 0; 893 s->v2x6 = 0; 894 s->cmd = -1; 895 896 dsp_out_data (s, 0xaa); 897 speaker (s, 0); 898 control (s, 0); 899 legacy_reset (s); 900 } 901 902 static void dsp_write(void *opaque, uint32_t nport, uint32_t val) 903 { 904 SB16State *s = opaque; 905 int iport; 906 907 iport = nport - s->port; 908 909 ldebug ("write %#x <- %#x\n", nport, val); 910 switch (iport) { 911 case 0x06: 912 switch (val) { 913 case 0x00: 914 if (s->v2x6 == 1) { 915 reset (s); 916 } 917 s->v2x6 = 0; 918 break; 919 920 case 0x01: 921 case 0x03: /* FreeBSD kludge */ 922 s->v2x6 = 1; 923 break; 924 925 case 0xc6: 926 s->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */ 927 break; 928 929 case 0xb8: /* Panic */ 930 reset (s); 931 break; 932 933 case 0x39: 934 dsp_out_data (s, 0x38); 935 reset (s); 936 s->v2x6 = 0x39; 937 break; 938 939 default: 940 s->v2x6 = val; 941 break; 942 } 943 break; 944 945 case 0x0c: /* write data or command | write status */ 946 /* if (s->highspeed) */ 947 /* break; */ 948 949 if (s->needed_bytes == 0) { 950 command (s, val); 951 #if 0 952 if (0 == s->needed_bytes) { 953 log_dsp (s); 954 } 955 #endif 956 } 957 else { 958 if (s->in_index == sizeof (s->in2_data)) { 959 dolog ("in data overrun\n"); 960 } 961 else { 962 s->in2_data[s->in_index++] = val; 963 if (s->in_index == s->needed_bytes) { 964 s->needed_bytes = 0; 965 complete (s); 966 #if 0 967 log_dsp (s); 968 #endif 969 } 970 } 971 } 972 break; 973 974 default: 975 ldebug ("(nport=%#x, val=%#x)\n", nport, val); 976 break; 977 } 978 } 979 980 static uint32_t dsp_read(void *opaque, uint32_t nport) 981 { 982 SB16State *s = opaque; 983 int iport, retval, ack = 0; 984 985 iport = nport - s->port; 986 987 switch (iport) { 988 case 0x06: /* reset */ 989 retval = 0xff; 990 break; 991 992 case 0x0a: /* read data */ 993 if (s->out_data_len) { 994 retval = s->out_data[--s->out_data_len]; 995 s->last_read_byte = retval; 996 } 997 else { 998 if (s->cmd != -1) { 999 dolog ("empty output buffer for command %#x\n", 1000 s->cmd); 1001 } 1002 retval = s->last_read_byte; 1003 /* goto error; */ 1004 } 1005 break; 1006 1007 case 0x0c: /* 0 can write */ 1008 retval = s->can_write ? 0 : 0x80; 1009 break; 1010 1011 case 0x0d: /* timer interrupt clear */ 1012 /* dolog ("timer interrupt clear\n"); */ 1013 retval = 0; 1014 break; 1015 1016 case 0x0e: /* data available status | irq 8 ack */ 1017 retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80; 1018 if (s->mixer_regs[0x82] & 1) { 1019 ack = 1; 1020 s->mixer_regs[0x82] &= ~1; 1021 qemu_irq_lower (s->pic); 1022 } 1023 break; 1024 1025 case 0x0f: /* irq 16 ack */ 1026 retval = 0xff; 1027 if (s->mixer_regs[0x82] & 2) { 1028 ack = 1; 1029 s->mixer_regs[0x82] &= ~2; 1030 qemu_irq_lower (s->pic); 1031 } 1032 break; 1033 1034 default: 1035 goto error; 1036 } 1037 1038 if (!ack) { 1039 ldebug ("read %#x -> %#x\n", nport, retval); 1040 } 1041 1042 return retval; 1043 1044 error: 1045 dolog ("warning: dsp_read %#x error\n", nport); 1046 return 0xff; 1047 } 1048 1049 static void reset_mixer (SB16State *s) 1050 { 1051 int i; 1052 1053 memset (s->mixer_regs, 0xff, 0x7f); 1054 memset (s->mixer_regs + 0x83, 0xff, sizeof (s->mixer_regs) - 0x83); 1055 1056 s->mixer_regs[0x02] = 4; /* master volume 3bits */ 1057 s->mixer_regs[0x06] = 4; /* MIDI volume 3bits */ 1058 s->mixer_regs[0x08] = 0; /* CD volume 3bits */ 1059 s->mixer_regs[0x0a] = 0; /* voice volume 2bits */ 1060 1061 /* d5=input filt, d3=lowpass filt, d1,d2=input source */ 1062 s->mixer_regs[0x0c] = 0; 1063 1064 /* d5=output filt, d1=stereo switch */ 1065 s->mixer_regs[0x0e] = 0; 1066 1067 /* voice volume L d5,d7, R d1,d3 */ 1068 s->mixer_regs[0x04] = (4 << 5) | (4 << 1); 1069 /* master ... */ 1070 s->mixer_regs[0x22] = (4 << 5) | (4 << 1); 1071 /* MIDI ... */ 1072 s->mixer_regs[0x26] = (4 << 5) | (4 << 1); 1073 1074 for (i = 0x30; i < 0x48; i++) { 1075 s->mixer_regs[i] = 0x20; 1076 } 1077 } 1078 1079 static void mixer_write_indexb(void *opaque, uint32_t nport, uint32_t val) 1080 { 1081 SB16State *s = opaque; 1082 (void) nport; 1083 s->mixer_nreg = val; 1084 } 1085 1086 static void mixer_write_datab(void *opaque, uint32_t nport, uint32_t val) 1087 { 1088 SB16State *s = opaque; 1089 1090 (void) nport; 1091 ldebug ("mixer_write [%#x] <- %#x\n", s->mixer_nreg, val); 1092 1093 switch (s->mixer_nreg) { 1094 case 0x00: 1095 reset_mixer (s); 1096 break; 1097 1098 case 0x80: 1099 { 1100 int irq = irq_of_magic (val); 1101 ldebug ("setting irq to %d (val=%#x)\n", irq, val); 1102 if (irq > 0) { 1103 s->irq = irq; 1104 } 1105 } 1106 break; 1107 1108 case 0x81: 1109 { 1110 int dma, hdma; 1111 1112 dma = ctz32 (val & 0xf); 1113 hdma = ctz32 (val & 0xf0); 1114 if (dma != s->dma || hdma != s->hdma) { 1115 qemu_log_mask(LOG_GUEST_ERROR, "attempt to change DMA 8bit" 1116 " %d(%d), 16bit %d(%d) (val=%#x)\n", dma, s->dma, 1117 hdma, s->hdma, val); 1118 } 1119 #if 0 1120 s->dma = dma; 1121 s->hdma = hdma; 1122 #endif 1123 } 1124 break; 1125 1126 case 0x82: 1127 qemu_log_mask(LOG_GUEST_ERROR, "attempt to write into IRQ status" 1128 " register (val=%#x)\n", val); 1129 return; 1130 1131 default: 1132 if (s->mixer_nreg >= 0x80) { 1133 ldebug ("attempt to write mixer[%#x] <- %#x\n", s->mixer_nreg, val); 1134 } 1135 break; 1136 } 1137 1138 s->mixer_regs[s->mixer_nreg] = val; 1139 } 1140 1141 static uint32_t mixer_read(void *opaque, uint32_t nport) 1142 { 1143 SB16State *s = opaque; 1144 1145 (void) nport; 1146 #ifndef DEBUG_SB16_MOST 1147 if (s->mixer_nreg != 0x82) { 1148 ldebug ("mixer_read[%#x] -> %#x\n", 1149 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]); 1150 } 1151 #else 1152 ldebug ("mixer_read[%#x] -> %#x\n", 1153 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]); 1154 #endif 1155 return s->mixer_regs[s->mixer_nreg]; 1156 } 1157 1158 static int write_audio (SB16State *s, int nchan, int dma_pos, 1159 int dma_len, int len) 1160 { 1161 IsaDma *isa_dma = nchan == s->dma ? s->isa_dma : s->isa_hdma; 1162 IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma); 1163 int temp, net; 1164 uint8_t tmpbuf[4096]; 1165 1166 temp = len; 1167 net = 0; 1168 1169 while (temp) { 1170 int left = dma_len - dma_pos; 1171 int copied; 1172 size_t to_copy; 1173 1174 to_copy = MIN (temp, left); 1175 if (to_copy > sizeof (tmpbuf)) { 1176 to_copy = sizeof (tmpbuf); 1177 } 1178 1179 copied = k->read_memory(isa_dma, nchan, tmpbuf, dma_pos, to_copy); 1180 copied = AUD_write (s->voice, tmpbuf, copied); 1181 1182 temp -= copied; 1183 dma_pos = (dma_pos + copied) % dma_len; 1184 net += copied; 1185 1186 if (!copied) { 1187 break; 1188 } 1189 } 1190 1191 return net; 1192 } 1193 1194 static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len) 1195 { 1196 SB16State *s = opaque; 1197 int till, copy, written, free; 1198 1199 if (s->block_size <= 0) { 1200 qemu_log_mask(LOG_GUEST_ERROR, "invalid block size=%d nchan=%d" 1201 " dma_pos=%d dma_len=%d\n", s->block_size, nchan, 1202 dma_pos, dma_len); 1203 return dma_pos; 1204 } 1205 1206 if (s->left_till_irq < 0) { 1207 s->left_till_irq = s->block_size; 1208 } 1209 1210 if (s->voice) { 1211 free = s->audio_free & ~s->align; 1212 if ((free <= 0) || !dma_len) { 1213 return dma_pos; 1214 } 1215 } 1216 else { 1217 free = dma_len; 1218 } 1219 1220 copy = free; 1221 till = s->left_till_irq; 1222 1223 #ifdef DEBUG_SB16_MOST 1224 dolog ("pos:%06d %d till:%d len:%d\n", 1225 dma_pos, free, till, dma_len); 1226 #endif 1227 1228 if (till <= copy) { 1229 if (s->dma_auto == 0) { 1230 copy = till; 1231 } 1232 } 1233 1234 written = write_audio (s, nchan, dma_pos, dma_len, copy); 1235 dma_pos = (dma_pos + written) % dma_len; 1236 s->left_till_irq -= written; 1237 1238 if (s->left_till_irq <= 0) { 1239 s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1; 1240 qemu_irq_raise (s->pic); 1241 if (s->dma_auto == 0) { 1242 control (s, 0); 1243 speaker (s, 0); 1244 } 1245 } 1246 1247 #ifdef DEBUG_SB16_MOST 1248 ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n", 1249 dma_pos, free, dma_len, s->left_till_irq, copy, written, 1250 s->block_size); 1251 #endif 1252 1253 while (s->left_till_irq <= 0) { 1254 s->left_till_irq = s->block_size + s->left_till_irq; 1255 } 1256 1257 return dma_pos; 1258 } 1259 1260 static void SB_audio_callback (void *opaque, int free) 1261 { 1262 SB16State *s = opaque; 1263 s->audio_free = free; 1264 } 1265 1266 static int sb16_post_load (void *opaque, int version_id) 1267 { 1268 SB16State *s = opaque; 1269 1270 if (s->voice) { 1271 AUD_close_out (&s->card, s->voice); 1272 s->voice = NULL; 1273 } 1274 1275 if (s->dma_running) { 1276 if (s->freq) { 1277 struct audsettings as; 1278 1279 s->audio_free = 0; 1280 1281 as.freq = s->freq; 1282 as.nchannels = 1 << s->fmt_stereo; 1283 as.fmt = s->fmt; 1284 as.endianness = 0; 1285 1286 s->voice = AUD_open_out ( 1287 &s->card, 1288 s->voice, 1289 "sb16", 1290 s, 1291 SB_audio_callback, 1292 &as 1293 ); 1294 } 1295 1296 control (s, 1); 1297 speaker (s, s->speaker); 1298 } 1299 return 0; 1300 } 1301 1302 static const VMStateDescription vmstate_sb16 = { 1303 .name = "sb16", 1304 .version_id = 1, 1305 .minimum_version_id = 1, 1306 .post_load = sb16_post_load, 1307 .fields = (VMStateField[]) { 1308 VMSTATE_UINT32 (irq, SB16State), 1309 VMSTATE_UINT32 (dma, SB16State), 1310 VMSTATE_UINT32 (hdma, SB16State), 1311 VMSTATE_UINT32 (port, SB16State), 1312 VMSTATE_UINT32 (ver, SB16State), 1313 VMSTATE_INT32 (in_index, SB16State), 1314 VMSTATE_INT32 (out_data_len, SB16State), 1315 VMSTATE_INT32 (fmt_stereo, SB16State), 1316 VMSTATE_INT32 (fmt_signed, SB16State), 1317 VMSTATE_INT32 (fmt_bits, SB16State), 1318 VMSTATE_UINT32 (fmt, SB16State), 1319 VMSTATE_INT32 (dma_auto, SB16State), 1320 VMSTATE_INT32 (block_size, SB16State), 1321 VMSTATE_INT32 (fifo, SB16State), 1322 VMSTATE_INT32 (freq, SB16State), 1323 VMSTATE_INT32 (time_const, SB16State), 1324 VMSTATE_INT32 (speaker, SB16State), 1325 VMSTATE_INT32 (needed_bytes, SB16State), 1326 VMSTATE_INT32 (cmd, SB16State), 1327 VMSTATE_INT32 (use_hdma, SB16State), 1328 VMSTATE_INT32 (highspeed, SB16State), 1329 VMSTATE_INT32 (can_write, SB16State), 1330 VMSTATE_INT32 (v2x6, SB16State), 1331 1332 VMSTATE_UINT8 (csp_param, SB16State), 1333 VMSTATE_UINT8 (csp_value, SB16State), 1334 VMSTATE_UINT8 (csp_mode, SB16State), 1335 VMSTATE_UINT8 (csp_param, SB16State), 1336 VMSTATE_BUFFER (csp_regs, SB16State), 1337 VMSTATE_UINT8 (csp_index, SB16State), 1338 VMSTATE_BUFFER (csp_reg83, SB16State), 1339 VMSTATE_INT32 (csp_reg83r, SB16State), 1340 VMSTATE_INT32 (csp_reg83w, SB16State), 1341 1342 VMSTATE_BUFFER (in2_data, SB16State), 1343 VMSTATE_BUFFER (out_data, SB16State), 1344 VMSTATE_UINT8 (test_reg, SB16State), 1345 VMSTATE_UINT8 (last_read_byte, SB16State), 1346 1347 VMSTATE_INT32 (nzero, SB16State), 1348 VMSTATE_INT32 (left_till_irq, SB16State), 1349 VMSTATE_INT32 (dma_running, SB16State), 1350 VMSTATE_INT32 (bytes_per_second, SB16State), 1351 VMSTATE_INT32 (align, SB16State), 1352 1353 VMSTATE_INT32 (mixer_nreg, SB16State), 1354 VMSTATE_BUFFER (mixer_regs, SB16State), 1355 1356 VMSTATE_END_OF_LIST () 1357 } 1358 }; 1359 1360 static const MemoryRegionPortio sb16_ioport_list[] = { 1361 { 4, 1, 1, .write = mixer_write_indexb }, 1362 { 5, 1, 1, .read = mixer_read, .write = mixer_write_datab }, 1363 { 6, 1, 1, .read = dsp_read, .write = dsp_write }, 1364 { 10, 1, 1, .read = dsp_read }, 1365 { 12, 1, 1, .write = dsp_write }, 1366 { 12, 4, 1, .read = dsp_read }, 1367 PORTIO_END_OF_LIST (), 1368 }; 1369 1370 1371 static void sb16_initfn (Object *obj) 1372 { 1373 SB16State *s = SB16 (obj); 1374 1375 s->cmd = -1; 1376 } 1377 1378 static void sb16_realizefn (DeviceState *dev, Error **errp) 1379 { 1380 ISADevice *isadev = ISA_DEVICE (dev); 1381 SB16State *s = SB16 (dev); 1382 IsaDmaClass *k; 1383 1384 s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma); 1385 s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma); 1386 if (!s->isa_dma || !s->isa_hdma) { 1387 error_setg(errp, "ISA controller does not support DMA"); 1388 return; 1389 } 1390 1391 isa_init_irq (isadev, &s->pic, s->irq); 1392 1393 s->mixer_regs[0x80] = magic_of_irq (s->irq); 1394 s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma); 1395 s->mixer_regs[0x82] = 2 << 5; 1396 1397 s->csp_regs[5] = 1; 1398 s->csp_regs[9] = 0xf8; 1399 1400 reset_mixer (s); 1401 s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s); 1402 if (!s->aux_ts) { 1403 error_setg(errp, "warning: Could not create auxiliary timer"); 1404 } 1405 1406 isa_register_portio_list(isadev, &s->portio_list, s->port, 1407 sb16_ioport_list, s, "sb16"); 1408 1409 k = ISADMA_GET_CLASS(s->isa_hdma); 1410 k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s); 1411 1412 k = ISADMA_GET_CLASS(s->isa_dma); 1413 k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s); 1414 1415 s->can_write = 1; 1416 1417 AUD_register_card ("sb16", &s->card); 1418 } 1419 1420 static Property sb16_properties[] = { 1421 DEFINE_AUDIO_PROPERTIES(SB16State, card), 1422 DEFINE_PROP_UINT32 ("version", SB16State, ver, 0x0405), /* 4.5 */ 1423 DEFINE_PROP_UINT32 ("iobase", SB16State, port, 0x220), 1424 DEFINE_PROP_UINT32 ("irq", SB16State, irq, 5), 1425 DEFINE_PROP_UINT32 ("dma", SB16State, dma, 1), 1426 DEFINE_PROP_UINT32 ("dma16", SB16State, hdma, 5), 1427 DEFINE_PROP_END_OF_LIST (), 1428 }; 1429 1430 static void sb16_class_initfn (ObjectClass *klass, void *data) 1431 { 1432 DeviceClass *dc = DEVICE_CLASS (klass); 1433 1434 dc->realize = sb16_realizefn; 1435 set_bit(DEVICE_CATEGORY_SOUND, dc->categories); 1436 dc->desc = "Creative Sound Blaster 16"; 1437 dc->vmsd = &vmstate_sb16; 1438 device_class_set_props(dc, sb16_properties); 1439 } 1440 1441 static const TypeInfo sb16_info = { 1442 .name = TYPE_SB16, 1443 .parent = TYPE_ISA_DEVICE, 1444 .instance_size = sizeof (SB16State), 1445 .instance_init = sb16_initfn, 1446 .class_init = sb16_class_initfn, 1447 }; 1448 1449 static void sb16_register_types (void) 1450 { 1451 type_register_static (&sb16_info); 1452 deprecated_register_soundhw("sb16", "Creative Sound Blaster 16", 1453 1, TYPE_SB16); 1454 } 1455 1456 type_init (sb16_register_types) 1457