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