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