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