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