vcs.maemo.org Git - qemu/blob - hw/sb16.c

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