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