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 0x41: 745 case 0x42: 746 /* 747 * 0x41 is documented as setting the output sample rate, 748 * and 0x42 the input sample rate, but in fact SB16 hardware 749 * seems to have only a single sample rate under the hood, 750 * and FT2 sets output freq with this (go figure). Compare: 751 * http://homepages.cae.wisc.edu/~brodskye/sb16doc/sb16doc.html#SamplingRate 752 */ 753 s->freq = dsp_get_hilo (s); 754 ldebug ("set freq %d\n", s->freq); 755 break; 756 757 case 0x48: 758 s->block_size = dsp_get_lohi (s) + 1; 759 ldebug ("set dma block len %d\n", s->block_size); 760 break; 761 762 case 0x74: 763 case 0x75: 764 case 0x76: 765 case 0x77: 766 /* ADPCM stuff, ignore */ 767 break; 768 769 case 0x80: 770 { 771 int freq, samples, bytes; 772 int64_t ticks; 773 774 freq = s->freq > 0 ? s->freq : 11025; 775 samples = dsp_get_lohi (s) + 1; 776 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16); 777 ticks = muldiv64(bytes, NANOSECONDS_PER_SECOND, freq); 778 if (ticks < NANOSECONDS_PER_SECOND / 1024) { 779 qemu_irq_raise (s->pic); 780 } 781 else { 782 if (s->aux_ts) { 783 timer_mod ( 784 s->aux_ts, 785 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ticks 786 ); 787 } 788 } 789 ldebug ("mix silence %d %d %" PRId64 "\n", samples, bytes, ticks); 790 } 791 break; 792 793 case 0xe0: 794 d0 = dsp_get_data (s); 795 s->out_data_len = 0; 796 ldebug ("E0 data = %#x\n", d0); 797 dsp_out_data (s, ~d0); 798 break; 799 800 case 0xe2: 801 #ifdef DEBUG 802 d0 = dsp_get_data (s); 803 dolog ("E2 = %#x\n", d0); 804 #endif 805 break; 806 807 case 0xe4: 808 s->test_reg = dsp_get_data (s); 809 break; 810 811 case 0xf9: 812 d0 = dsp_get_data (s); 813 ldebug ("command 0xf9 with %#x\n", d0); 814 switch (d0) { 815 case 0x0e: 816 dsp_out_data (s, 0xff); 817 break; 818 819 case 0x0f: 820 dsp_out_data (s, 0x07); 821 break; 822 823 case 0x37: 824 dsp_out_data (s, 0x38); 825 break; 826 827 default: 828 dsp_out_data (s, 0x00); 829 break; 830 } 831 break; 832 833 default: 834 qemu_log_mask(LOG_UNIMP, "complete: unrecognized command %#x\n", 835 s->cmd); 836 return; 837 } 838 } 839 840 ldebug ("\n"); 841 s->cmd = -1; 842 } 843 844 static void legacy_reset (SB16State *s) 845 { 846 struct audsettings as; 847 848 s->freq = 11025; 849 s->fmt_signed = 0; 850 s->fmt_bits = 8; 851 s->fmt_stereo = 0; 852 853 as.freq = s->freq; 854 as.nchannels = 1; 855 as.fmt = AUD_FMT_U8; 856 as.endianness = 0; 857 858 s->voice = AUD_open_out ( 859 &s->card, 860 s->voice, 861 "sb16", 862 s, 863 SB_audio_callback, 864 &as 865 ); 866 867 /* Not sure about that... */ 868 /* AUD_set_active_out (s->voice, 1); */ 869 } 870 871 static void reset (SB16State *s) 872 { 873 qemu_irq_lower (s->pic); 874 if (s->dma_auto) { 875 qemu_irq_raise (s->pic); 876 qemu_irq_lower (s->pic); 877 } 878 879 s->mixer_regs[0x82] = 0; 880 s->dma_auto = 0; 881 s->in_index = 0; 882 s->out_data_len = 0; 883 s->left_till_irq = 0; 884 s->needed_bytes = 0; 885 s->block_size = -1; 886 s->nzero = 0; 887 s->highspeed = 0; 888 s->v2x6 = 0; 889 s->cmd = -1; 890 891 dsp_out_data (s, 0xaa); 892 speaker (s, 0); 893 control (s, 0); 894 legacy_reset (s); 895 } 896 897 static void dsp_write(void *opaque, uint32_t nport, uint32_t val) 898 { 899 SB16State *s = opaque; 900 int iport; 901 902 iport = nport - s->port; 903 904 ldebug ("write %#x <- %#x\n", nport, val); 905 switch (iport) { 906 case 0x06: 907 switch (val) { 908 case 0x00: 909 if (s->v2x6 == 1) { 910 reset (s); 911 } 912 s->v2x6 = 0; 913 break; 914 915 case 0x01: 916 case 0x03: /* FreeBSD kludge */ 917 s->v2x6 = 1; 918 break; 919 920 case 0xc6: 921 s->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */ 922 break; 923 924 case 0xb8: /* Panic */ 925 reset (s); 926 break; 927 928 case 0x39: 929 dsp_out_data (s, 0x38); 930 reset (s); 931 s->v2x6 = 0x39; 932 break; 933 934 default: 935 s->v2x6 = val; 936 break; 937 } 938 break; 939 940 case 0x0c: /* write data or command | write status */ 941 /* if (s->highspeed) */ 942 /* break; */ 943 944 if (s->needed_bytes == 0) { 945 command (s, val); 946 #if 0 947 if (0 == s->needed_bytes) { 948 log_dsp (s); 949 } 950 #endif 951 } 952 else { 953 if (s->in_index == sizeof (s->in2_data)) { 954 dolog ("in data overrun\n"); 955 } 956 else { 957 s->in2_data[s->in_index++] = val; 958 if (s->in_index == s->needed_bytes) { 959 s->needed_bytes = 0; 960 complete (s); 961 #if 0 962 log_dsp (s); 963 #endif 964 } 965 } 966 } 967 break; 968 969 default: 970 ldebug ("(nport=%#x, val=%#x)\n", nport, val); 971 break; 972 } 973 } 974 975 static uint32_t dsp_read(void *opaque, uint32_t nport) 976 { 977 SB16State *s = opaque; 978 int iport, retval, ack = 0; 979 980 iport = nport - s->port; 981 982 switch (iport) { 983 case 0x06: /* reset */ 984 retval = 0xff; 985 break; 986 987 case 0x0a: /* read data */ 988 if (s->out_data_len) { 989 retval = s->out_data[--s->out_data_len]; 990 s->last_read_byte = retval; 991 } 992 else { 993 if (s->cmd != -1) { 994 dolog ("empty output buffer for command %#x\n", 995 s->cmd); 996 } 997 retval = s->last_read_byte; 998 /* goto error; */ 999 } 1000 break; 1001 1002 case 0x0c: /* 0 can write */ 1003 retval = s->can_write ? 0 : 0x80; 1004 break; 1005 1006 case 0x0d: /* timer interrupt clear */ 1007 /* dolog ("timer interrupt clear\n"); */ 1008 retval = 0; 1009 break; 1010 1011 case 0x0e: /* data available status | irq 8 ack */ 1012 retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80; 1013 if (s->mixer_regs[0x82] & 1) { 1014 ack = 1; 1015 s->mixer_regs[0x82] &= ~1; 1016 qemu_irq_lower (s->pic); 1017 } 1018 break; 1019 1020 case 0x0f: /* irq 16 ack */ 1021 retval = 0xff; 1022 if (s->mixer_regs[0x82] & 2) { 1023 ack = 1; 1024 s->mixer_regs[0x82] &= ~2; 1025 qemu_irq_lower (s->pic); 1026 } 1027 break; 1028 1029 default: 1030 goto error; 1031 } 1032 1033 if (!ack) { 1034 ldebug ("read %#x -> %#x\n", nport, retval); 1035 } 1036 1037 return retval; 1038 1039 error: 1040 dolog ("warning: dsp_read %#x error\n", nport); 1041 return 0xff; 1042 } 1043 1044 static void reset_mixer (SB16State *s) 1045 { 1046 int i; 1047 1048 memset (s->mixer_regs, 0xff, 0x7f); 1049 memset (s->mixer_regs + 0x83, 0xff, sizeof (s->mixer_regs) - 0x83); 1050 1051 s->mixer_regs[0x02] = 4; /* master volume 3bits */ 1052 s->mixer_regs[0x06] = 4; /* MIDI volume 3bits */ 1053 s->mixer_regs[0x08] = 0; /* CD volume 3bits */ 1054 s->mixer_regs[0x0a] = 0; /* voice volume 2bits */ 1055 1056 /* d5=input filt, d3=lowpass filt, d1,d2=input source */ 1057 s->mixer_regs[0x0c] = 0; 1058 1059 /* d5=output filt, d1=stereo switch */ 1060 s->mixer_regs[0x0e] = 0; 1061 1062 /* voice volume L d5,d7, R d1,d3 */ 1063 s->mixer_regs[0x04] = (4 << 5) | (4 << 1); 1064 /* master ... */ 1065 s->mixer_regs[0x22] = (4 << 5) | (4 << 1); 1066 /* MIDI ... */ 1067 s->mixer_regs[0x26] = (4 << 5) | (4 << 1); 1068 1069 for (i = 0x30; i < 0x48; i++) { 1070 s->mixer_regs[i] = 0x20; 1071 } 1072 } 1073 1074 static void mixer_write_indexb(void *opaque, uint32_t nport, uint32_t val) 1075 { 1076 SB16State *s = opaque; 1077 (void) nport; 1078 s->mixer_nreg = val; 1079 } 1080 1081 static void mixer_write_datab(void *opaque, uint32_t nport, uint32_t val) 1082 { 1083 SB16State *s = opaque; 1084 1085 (void) nport; 1086 ldebug ("mixer_write [%#x] <- %#x\n", s->mixer_nreg, val); 1087 1088 switch (s->mixer_nreg) { 1089 case 0x00: 1090 reset_mixer (s); 1091 break; 1092 1093 case 0x80: 1094 { 1095 int irq = irq_of_magic (val); 1096 ldebug ("setting irq to %d (val=%#x)\n", irq, val); 1097 if (irq > 0) { 1098 s->irq = irq; 1099 } 1100 } 1101 break; 1102 1103 case 0x81: 1104 { 1105 int dma, hdma; 1106 1107 dma = ctz32 (val & 0xf); 1108 hdma = ctz32 (val & 0xf0); 1109 if (dma != s->dma || hdma != s->hdma) { 1110 qemu_log_mask(LOG_GUEST_ERROR, "attempt to change DMA 8bit" 1111 " %d(%d), 16bit %d(%d) (val=%#x)\n", dma, s->dma, 1112 hdma, s->hdma, val); 1113 } 1114 #if 0 1115 s->dma = dma; 1116 s->hdma = hdma; 1117 #endif 1118 } 1119 break; 1120 1121 case 0x82: 1122 qemu_log_mask(LOG_GUEST_ERROR, "attempt to write into IRQ status" 1123 " register (val=%#x)\n", val); 1124 return; 1125 1126 default: 1127 if (s->mixer_nreg >= 0x80) { 1128 ldebug ("attempt to write mixer[%#x] <- %#x\n", s->mixer_nreg, val); 1129 } 1130 break; 1131 } 1132 1133 s->mixer_regs[s->mixer_nreg] = val; 1134 } 1135 1136 static uint32_t mixer_read(void *opaque, uint32_t nport) 1137 { 1138 SB16State *s = opaque; 1139 1140 (void) nport; 1141 #ifndef DEBUG_SB16_MOST 1142 if (s->mixer_nreg != 0x82) { 1143 ldebug ("mixer_read[%#x] -> %#x\n", 1144 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]); 1145 } 1146 #else 1147 ldebug ("mixer_read[%#x] -> %#x\n", 1148 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]); 1149 #endif 1150 return s->mixer_regs[s->mixer_nreg]; 1151 } 1152 1153 static int write_audio (SB16State *s, int nchan, int dma_pos, 1154 int dma_len, int len) 1155 { 1156 IsaDma *isa_dma = nchan == s->dma ? s->isa_dma : s->isa_hdma; 1157 IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma); 1158 int temp, net; 1159 uint8_t tmpbuf[4096]; 1160 1161 temp = len; 1162 net = 0; 1163 1164 while (temp) { 1165 int left = dma_len - dma_pos; 1166 int copied; 1167 size_t to_copy; 1168 1169 to_copy = audio_MIN (temp, left); 1170 if (to_copy > sizeof (tmpbuf)) { 1171 to_copy = sizeof (tmpbuf); 1172 } 1173 1174 copied = k->read_memory(isa_dma, nchan, tmpbuf, dma_pos, to_copy); 1175 copied = AUD_write (s->voice, tmpbuf, copied); 1176 1177 temp -= copied; 1178 dma_pos = (dma_pos + copied) % dma_len; 1179 net += copied; 1180 1181 if (!copied) { 1182 break; 1183 } 1184 } 1185 1186 return net; 1187 } 1188 1189 static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len) 1190 { 1191 SB16State *s = opaque; 1192 int till, copy, written, free; 1193 1194 if (s->block_size <= 0) { 1195 qemu_log_mask(LOG_GUEST_ERROR, "invalid block size=%d nchan=%d" 1196 " dma_pos=%d dma_len=%d\n", s->block_size, nchan, 1197 dma_pos, dma_len); 1198 return dma_pos; 1199 } 1200 1201 if (s->left_till_irq < 0) { 1202 s->left_till_irq = s->block_size; 1203 } 1204 1205 if (s->voice) { 1206 free = s->audio_free & ~s->align; 1207 if ((free <= 0) || !dma_len) { 1208 return dma_pos; 1209 } 1210 } 1211 else { 1212 free = dma_len; 1213 } 1214 1215 copy = free; 1216 till = s->left_till_irq; 1217 1218 #ifdef DEBUG_SB16_MOST 1219 dolog ("pos:%06d %d till:%d len:%d\n", 1220 dma_pos, free, till, dma_len); 1221 #endif 1222 1223 if (till <= copy) { 1224 if (s->dma_auto == 0) { 1225 copy = till; 1226 } 1227 } 1228 1229 written = write_audio (s, nchan, dma_pos, dma_len, copy); 1230 dma_pos = (dma_pos + written) % dma_len; 1231 s->left_till_irq -= written; 1232 1233 if (s->left_till_irq <= 0) { 1234 s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1; 1235 qemu_irq_raise (s->pic); 1236 if (s->dma_auto == 0) { 1237 control (s, 0); 1238 speaker (s, 0); 1239 } 1240 } 1241 1242 #ifdef DEBUG_SB16_MOST 1243 ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n", 1244 dma_pos, free, dma_len, s->left_till_irq, copy, written, 1245 s->block_size); 1246 #endif 1247 1248 while (s->left_till_irq <= 0) { 1249 s->left_till_irq = s->block_size + s->left_till_irq; 1250 } 1251 1252 return dma_pos; 1253 } 1254 1255 static void SB_audio_callback (void *opaque, int free) 1256 { 1257 SB16State *s = opaque; 1258 s->audio_free = free; 1259 } 1260 1261 static int sb16_post_load (void *opaque, int version_id) 1262 { 1263 SB16State *s = opaque; 1264 1265 if (s->voice) { 1266 AUD_close_out (&s->card, s->voice); 1267 s->voice = NULL; 1268 } 1269 1270 if (s->dma_running) { 1271 if (s->freq) { 1272 struct audsettings as; 1273 1274 s->audio_free = 0; 1275 1276 as.freq = s->freq; 1277 as.nchannels = 1 << s->fmt_stereo; 1278 as.fmt = s->fmt; 1279 as.endianness = 0; 1280 1281 s->voice = AUD_open_out ( 1282 &s->card, 1283 s->voice, 1284 "sb16", 1285 s, 1286 SB_audio_callback, 1287 &as 1288 ); 1289 } 1290 1291 control (s, 1); 1292 speaker (s, s->speaker); 1293 } 1294 return 0; 1295 } 1296 1297 static const VMStateDescription vmstate_sb16 = { 1298 .name = "sb16", 1299 .version_id = 1, 1300 .minimum_version_id = 1, 1301 .post_load = sb16_post_load, 1302 .fields = (VMStateField[]) { 1303 VMSTATE_UINT32 (irq, SB16State), 1304 VMSTATE_UINT32 (dma, SB16State), 1305 VMSTATE_UINT32 (hdma, SB16State), 1306 VMSTATE_UINT32 (port, SB16State), 1307 VMSTATE_UINT32 (ver, SB16State), 1308 VMSTATE_INT32 (in_index, SB16State), 1309 VMSTATE_INT32 (out_data_len, SB16State), 1310 VMSTATE_INT32 (fmt_stereo, SB16State), 1311 VMSTATE_INT32 (fmt_signed, SB16State), 1312 VMSTATE_INT32 (fmt_bits, SB16State), 1313 VMSTATE_UINT32 (fmt, SB16State), 1314 VMSTATE_INT32 (dma_auto, SB16State), 1315 VMSTATE_INT32 (block_size, SB16State), 1316 VMSTATE_INT32 (fifo, SB16State), 1317 VMSTATE_INT32 (freq, SB16State), 1318 VMSTATE_INT32 (time_const, SB16State), 1319 VMSTATE_INT32 (speaker, SB16State), 1320 VMSTATE_INT32 (needed_bytes, SB16State), 1321 VMSTATE_INT32 (cmd, SB16State), 1322 VMSTATE_INT32 (use_hdma, SB16State), 1323 VMSTATE_INT32 (highspeed, SB16State), 1324 VMSTATE_INT32 (can_write, SB16State), 1325 VMSTATE_INT32 (v2x6, SB16State), 1326 1327 VMSTATE_UINT8 (csp_param, SB16State), 1328 VMSTATE_UINT8 (csp_value, SB16State), 1329 VMSTATE_UINT8 (csp_mode, SB16State), 1330 VMSTATE_UINT8 (csp_param, SB16State), 1331 VMSTATE_BUFFER (csp_regs, SB16State), 1332 VMSTATE_UINT8 (csp_index, SB16State), 1333 VMSTATE_BUFFER (csp_reg83, SB16State), 1334 VMSTATE_INT32 (csp_reg83r, SB16State), 1335 VMSTATE_INT32 (csp_reg83w, SB16State), 1336 1337 VMSTATE_BUFFER (in2_data, SB16State), 1338 VMSTATE_BUFFER (out_data, SB16State), 1339 VMSTATE_UINT8 (test_reg, SB16State), 1340 VMSTATE_UINT8 (last_read_byte, SB16State), 1341 1342 VMSTATE_INT32 (nzero, SB16State), 1343 VMSTATE_INT32 (left_till_irq, SB16State), 1344 VMSTATE_INT32 (dma_running, SB16State), 1345 VMSTATE_INT32 (bytes_per_second, SB16State), 1346 VMSTATE_INT32 (align, SB16State), 1347 1348 VMSTATE_INT32 (mixer_nreg, SB16State), 1349 VMSTATE_BUFFER (mixer_regs, SB16State), 1350 1351 VMSTATE_END_OF_LIST () 1352 } 1353 }; 1354 1355 static const MemoryRegionPortio sb16_ioport_list[] = { 1356 { 4, 1, 1, .write = mixer_write_indexb }, 1357 { 5, 1, 1, .read = mixer_read, .write = mixer_write_datab }, 1358 { 6, 1, 1, .read = dsp_read, .write = dsp_write }, 1359 { 10, 1, 1, .read = dsp_read }, 1360 { 12, 1, 1, .write = dsp_write }, 1361 { 12, 4, 1, .read = dsp_read }, 1362 PORTIO_END_OF_LIST (), 1363 }; 1364 1365 1366 static void sb16_initfn (Object *obj) 1367 { 1368 SB16State *s = SB16 (obj); 1369 1370 s->cmd = -1; 1371 } 1372 1373 static void sb16_realizefn (DeviceState *dev, Error **errp) 1374 { 1375 ISADevice *isadev = ISA_DEVICE (dev); 1376 SB16State *s = SB16 (dev); 1377 IsaDmaClass *k; 1378 1379 s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma); 1380 s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma); 1381 if (!s->isa_dma || !s->isa_hdma) { 1382 error_setg(errp, "ISA controller does not support DMA"); 1383 return; 1384 } 1385 1386 isa_init_irq (isadev, &s->pic, s->irq); 1387 1388 s->mixer_regs[0x80] = magic_of_irq (s->irq); 1389 s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma); 1390 s->mixer_regs[0x82] = 2 << 5; 1391 1392 s->csp_regs[5] = 1; 1393 s->csp_regs[9] = 0xf8; 1394 1395 reset_mixer (s); 1396 s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s); 1397 if (!s->aux_ts) { 1398 error_setg(errp, "warning: Could not create auxiliary timer"); 1399 } 1400 1401 isa_register_portio_list(isadev, &s->portio_list, s->port, 1402 sb16_ioport_list, s, "sb16"); 1403 1404 k = ISADMA_GET_CLASS(s->isa_hdma); 1405 k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s); 1406 1407 k = ISADMA_GET_CLASS(s->isa_dma); 1408 k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s); 1409 1410 s->can_write = 1; 1411 1412 AUD_register_card ("sb16", &s->card); 1413 } 1414 1415 static int SB16_init (ISABus *bus) 1416 { 1417 isa_create_simple (bus, TYPE_SB16); 1418 return 0; 1419 } 1420 1421 static Property sb16_properties[] = { 1422 DEFINE_PROP_UINT32 ("version", SB16State, ver, 0x0405), /* 4.5 */ 1423 DEFINE_PROP_UINT32 ("iobase", SB16State, port, 0x220), 1424 DEFINE_PROP_UINT32 ("irq", SB16State, irq, 5), 1425 DEFINE_PROP_UINT32 ("dma", SB16State, dma, 1), 1426 DEFINE_PROP_UINT32 ("dma16", SB16State, hdma, 5), 1427 DEFINE_PROP_END_OF_LIST (), 1428 }; 1429 1430 static void sb16_class_initfn (ObjectClass *klass, void *data) 1431 { 1432 DeviceClass *dc = DEVICE_CLASS (klass); 1433 1434 dc->realize = sb16_realizefn; 1435 set_bit(DEVICE_CATEGORY_SOUND, dc->categories); 1436 dc->desc = "Creative Sound Blaster 16"; 1437 dc->vmsd = &vmstate_sb16; 1438 dc->props = sb16_properties; 1439 } 1440 1441 static const TypeInfo sb16_info = { 1442 .name = TYPE_SB16, 1443 .parent = TYPE_ISA_DEVICE, 1444 .instance_size = sizeof (SB16State), 1445 .instance_init = sb16_initfn, 1446 .class_init = sb16_class_initfn, 1447 }; 1448 1449 static void sb16_register_types (void) 1450 { 1451 type_register_static (&sb16_info); 1452 isa_register_soundhw("sb16", "Creative Sound Blaster 16", SB16_init); 1453 } 1454 1455 type_init (sb16_register_types) 1456