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