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