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