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