Merge remote-tracking branch 'remotes/kraxel/tags/ui-20180202-pull-request' into...

[qemu.git] / hw / audio / sb16.c

diff --git a/hw/audio/sb16.c b/hw/audio/sb16.c
index bb24e00f2ce73afbd17fa7e14b1c7b384895c483..31de264ab7bc37d02c128d84f479bd45beba5314 100644 (file)
--- a/hw/audio/sb16.c
+++ b/hw/audio/sb16.c
@@ -21,13 +21,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

+#include "qemu/osdep.h"

 #include "hw/hw.h"
 #include "hw/hw.h"

-#include "hw/audio/audio.h"
+#include "hw/audio/soundhw.h"

 #include "audio/audio.h"
 #include "hw/isa/isa.h"
 #include "hw/qdev.h"
 #include "qemu/timer.h"
 #include "qemu/host-utils.h"
 #include "audio/audio.h"
 #include "hw/isa/isa.h"
 #include "hw/qdev.h"
 #include "qemu/timer.h"
 #include "qemu/host-utils.h"

+#include "qemu/log.h"
+#include "qapi/error.h"

 
 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
 
 
 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
 


@@ -40,11 +43,6 @@
 #define ldebug(...)
 #endif
 
 #define ldebug(...)
 #endif
 

-#define IO_READ_PROTO(name)                             \
-    uint32_t name (void *opaque, uint32_t nport)
-#define IO_WRITE_PROTO(name)                                    \
-    void name (void *opaque, uint32_t nport, uint32_t val)
-

 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
 
 #define TYPE_SB16 "sb16"
 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
 
 #define TYPE_SB16 "sb16"


@@ -60,6 +58,8 @@ typedef struct SB16State {
     uint32_t hdma;
     uint32_t port;
     uint32_t ver;
     uint32_t hdma;
     uint32_t port;
     uint32_t ver;

+    IsaDma *isa_dma;
+    IsaDma *isa_hdma;

 
     int in_index;
     int out_data_len;
 
     int in_index;
     int out_data_len;


@@ -108,6 +108,7 @@ typedef struct SB16State {
     /* mixer state */
     int mixer_nreg;
     uint8_t mixer_regs[256];
     /* mixer state */
     int mixer_nreg;
     uint8_t mixer_regs[256];

+    PortioList portio_list;

 } SB16State;
 
 static void SB_audio_callback (void *opaque, int free);
 } SB16State;
 
 static void SB_audio_callback (void *opaque, int free);


@@ -124,7 +125,7 @@ static int magic_of_irq (int irq)
     case 10:
         return 8;
     default:
     case 10:
         return 8;
     default:

-        dolog ("bad irq %d\n", irq);
+        qemu_log_mask(LOG_GUEST_ERROR, "bad irq %d\n", irq);

         return 2;
     }
 }
         return 2;
     }
 }


@@ -141,7 +142,7 @@ static int irq_of_magic (int magic)
     case 8:
         return 10;
     default:
     case 8:
         return 10;
     default:

-        dolog ("bad irq magic %d\n", magic);
+        qemu_log_mask(LOG_GUEST_ERROR, "bad irq magic %d\n", magic);

         return -1;
     }
 }
         return -1;
     }
 }


@@ -170,16 +171,18 @@ static void speaker (SB16State *s, int on)
 static void control (SB16State *s, int hold)
 {
     int dma = s->use_hdma ? s->hdma : s->dma;
 static void control (SB16State *s, int hold)
 {
     int dma = s->use_hdma ? s->hdma : s->dma;

+    IsaDma *isa_dma = s->use_hdma ? s->isa_hdma : s->isa_dma;
+    IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma);

     s->dma_running = hold;
 
     ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);
 
     if (hold) {
     s->dma_running = hold;
 
     ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);
 
     if (hold) {

-        DMA_hold_DREQ (dma);
+        k->hold_DREQ(isa_dma, dma);

         AUD_set_active_out (s->voice, 1);
     }
     else {
         AUD_set_active_out (s->voice, 1);
     }
     else {

-        DMA_release_DREQ (dma);
+        k->release_DREQ(isa_dma, dma);

         AUD_set_active_out (s->voice, 0);
     }
 }
         AUD_set_active_out (s->voice, 0);
     }
 }


@@ -257,8 +260,8 @@ static void dma_cmd8 (SB16State *s, int mask, int dma_len)
     s->align = (1 << s->fmt_stereo) - 1;
 
     if (s->block_size & s->align) {
     s->align = (1 << s->fmt_stereo) - 1;
 
     if (s->block_size & s->align) {

-        dolog ("warning: misaligned block size %d, alignment %d\n",
-               s->block_size, s->align + 1);
+        qemu_log_mask(LOG_GUEST_ERROR, "warning: misaligned block size %d,"
+                      " alignment %d\n", s->block_size, s->align + 1);

     }
 
     ldebug ("freq %d, stereo %d, sign %d, bits %d, "
     }
 
     ldebug ("freq %d, stereo %d, sign %d, bits %d, "


@@ -337,8 +340,8 @@ static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len)
     s->highspeed = 0;
     s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;
     if (s->block_size & s->align) {
     s->highspeed = 0;
     s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;
     if (s->block_size & s->align) {

-        dolog ("warning: misaligned block size %d, alignment %d\n",
-               s->block_size, s->align + 1);
+        qemu_log_mask(LOG_GUEST_ERROR, "warning: misaligned block size %d,"
+                      " alignment %d\n", s->block_size, s->align + 1);

     }
 
     if (s->freq) {
     }
 
     if (s->freq) {


@@ -390,7 +393,8 @@ static void command (SB16State *s, uint8_t cmd)
 
     if (cmd > 0xaf && cmd < 0xd0) {
         if (cmd & 8) {
 
     if (cmd > 0xaf && cmd < 0xd0) {
         if (cmd & 8) {

-            dolog ("ADC not yet supported (command %#x)\n", cmd);
+            qemu_log_mask(LOG_UNIMP, "ADC not yet supported (command %#x)\n",
+                          cmd);

         }
 
         switch (cmd >> 4) {
         }
 
         switch (cmd >> 4) {


@@ -398,7 +402,7 @@ static void command (SB16State *s, uint8_t cmd)
         case 12:
             break;
         default:
         case 12:
             break;
         default:

-            dolog ("%#x wrong bits\n", cmd);
+            qemu_log_mask(LOG_GUEST_ERROR, "%#x wrong bits\n", cmd);

         }
         s->needed_bytes = 3;
     }
         }
         s->needed_bytes = 3;
     }


@@ -452,7 +456,7 @@ static void command (SB16State *s, uint8_t cmd)
             goto warn;
 
         case 0x35:
             goto warn;
 
         case 0x35:

-            dolog ("0x35 - MIDI command not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x35 - MIDI command not implemented\n");

             break;
 
         case 0x40:
             break;
 
         case 0x40:


@@ -486,34 +490,38 @@ static void command (SB16State *s, uint8_t cmd)
 
         case 0x74:
             s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */
 
         case 0x74:
             s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */

-            dolog ("0x75 - DMA DAC, 4-bit ADPCM not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x75 - DMA DAC, 4-bit ADPCM not"
+                          " implemented\n");

             break;
 
         case 0x75:              /* DMA DAC, 4-bit ADPCM Reference */
             s->needed_bytes = 2;
             break;
 
         case 0x75:              /* DMA DAC, 4-bit ADPCM Reference */
             s->needed_bytes = 2;

-            dolog ("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 4-bit ADPCM Reference not"
+                          " implemented\n");

             break;
 
         case 0x76:              /* DMA DAC, 2.6-bit ADPCM */
             s->needed_bytes = 2;
             break;
 
         case 0x76:              /* DMA DAC, 2.6-bit ADPCM */
             s->needed_bytes = 2;

-            dolog ("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 2.6-bit ADPCM not"
+                          " implemented\n");

             break;
 
         case 0x77:              /* DMA DAC, 2.6-bit ADPCM Reference */
             s->needed_bytes = 2;
             break;
 
         case 0x77:              /* DMA DAC, 2.6-bit ADPCM Reference */
             s->needed_bytes = 2;

-            dolog ("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x74 - DMA DAC, 2.6-bit ADPCM Reference"
+                          " not implemented\n");

             break;
 
         case 0x7d:
             break;
 
         case 0x7d:

-            dolog ("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n");
-            dolog ("not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x7d - Autio-Initialize DMA DAC, 4-bit"
+                          " ADPCM Reference\n");
+            qemu_log_mask(LOG_UNIMP, "not implemented\n");

             break;
 
         case 0x7f:
             break;
 
         case 0x7f:

-            dolog (
-                "0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"
-                );
-            dolog ("not implemented\n");
+            qemu_log_mask(LOG_UNIMP, "0x7d - Autio-Initialize DMA DAC, 2.6-bit"
+                          " ADPCM Reference\n");
+            qemu_log_mask(LOG_UNIMP, "not implemented\n");

             break;
 
         case 0x80:
             break;
 
         case 0x80:


@@ -585,7 +593,7 @@ static void command (SB16State *s, uint8_t cmd)
             break;
 
         case 0xe7:
             break;
 
         case 0xe7:

-            dolog ("Attempt to probe for ESS (0xe7)?\n");
+            qemu_log_mask(LOG_UNIMP, "Attempt to probe for ESS (0xe7)?\n");

             break;
 
         case 0xe8:              /* read test reg */
             break;
 
         case 0xe8:              /* read test reg */


@@ -612,7 +620,7 @@ static void command (SB16State *s, uint8_t cmd)
             goto warn;
 
         default:
             goto warn;
 
         default:

-            dolog ("Unrecognized command %#x\n", cmd);
+            qemu_log_mask(LOG_UNIMP, "Unrecognized command %#x\n", cmd);

             break;
         }
     }
             break;
         }
     }


@@ -631,8 +639,8 @@ static void command (SB16State *s, uint8_t cmd)
     return;
 
  warn:
     return;
 
  warn:

-    dolog ("warning: command %#x,%d is not truly understood yet\n",
-           cmd, s->needed_bytes);
+    qemu_log_mask(LOG_UNIMP, "warning: command %#x,%d is not truly understood"
+                  " yet\n", cmd, s->needed_bytes);

     goto exit;
 
 }
     goto exit;
 
 }


@@ -734,9 +742,8 @@ static void complete (SB16State *s)
             break;
 
         case 0x42:              /* FT2 sets output freq with this, go figure */
             break;
 
         case 0x42:              /* FT2 sets output freq with this, go figure */

-#if 0
-            dolog ("cmd 0x42 might not do what it think it should\n");
-#endif
+            qemu_log_mask(LOG_UNIMP, "cmd 0x42 might not do what it think it"
+                          " should\n");

         case 0x41:
             s->freq = dsp_get_hilo (s);
             ldebug ("set freq %d\n", s->freq);
         case 0x41:
             s->freq = dsp_get_hilo (s);
             ldebug ("set freq %d\n", s->freq);


@@ -762,8 +769,8 @@ static void complete (SB16State *s)
                 freq = s->freq > 0 ? s->freq : 11025;
                 samples = dsp_get_lohi (s) + 1;
                 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16);
                 freq = s->freq > 0 ? s->freq : 11025;
                 samples = dsp_get_lohi (s) + 1;
                 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16);

-                ticks = muldiv64 (bytes, get_ticks_per_sec (), freq);
-                if (ticks < get_ticks_per_sec () / 1024) {
+                ticks = muldiv64(bytes, NANOSECONDS_PER_SECOND, freq);
+                if (ticks < NANOSECONDS_PER_SECOND / 1024) {

                     qemu_irq_raise (s->pic);
                 }
                 else {
                     qemu_irq_raise (s->pic);
                 }
                 else {


@@ -819,7 +826,8 @@ static void complete (SB16State *s)
             break;
 
         default:
             break;
 
         default:

-            dolog ("complete: unrecognized command %#x\n", s->cmd);
+            qemu_log_mask(LOG_UNIMP, "complete: unrecognized command %#x\n",
+                          s->cmd);

             return;
         }
     }
             return;
         }
     }


@@ -881,7 +889,7 @@ static void reset (SB16State *s)
     legacy_reset (s);
 }
 
     legacy_reset (s);
 }
 

-static IO_WRITE_PROTO (dsp_write)
+static void dsp_write(void *opaque, uint32_t nport, uint32_t val)

 {
     SB16State *s = opaque;
     int iport;
 {
     SB16State *s = opaque;
     int iport;


@@ -928,7 +936,7 @@ static IO_WRITE_PROTO (dsp_write)
 /*         if (s->highspeed) */
 /*             break; */
 
 /*         if (s->highspeed) */
 /*             break; */
 

-        if (0 == s->needed_bytes) {
+        if (s->needed_bytes == 0) {

             command (s, val);
 #if 0
             if (0 == s->needed_bytes) {
             command (s, val);
 #if 0
             if (0 == s->needed_bytes) {


@@ -959,7 +967,7 @@ static IO_WRITE_PROTO (dsp_write)
     }
 }
 
     }
 }
 

-static IO_READ_PROTO (dsp_read)
+static uint32_t dsp_read(void *opaque, uint32_t nport)

 {
     SB16State *s = opaque;
     int iport, retval, ack = 0;
 {
     SB16State *s = opaque;
     int iport, retval, ack = 0;


@@ -999,7 +1007,7 @@ static IO_READ_PROTO (dsp_read)
         retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80;
         if (s->mixer_regs[0x82] & 1) {
             ack = 1;
         retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80;
         if (s->mixer_regs[0x82] & 1) {
             ack = 1;

-            s->mixer_regs[0x82] &= 1;
+            s->mixer_regs[0x82] &= ~1;

             qemu_irq_lower (s->pic);
         }
         break;
             qemu_irq_lower (s->pic);
         }
         break;


@@ -1008,7 +1016,7 @@ static IO_READ_PROTO (dsp_read)
         retval = 0xff;
         if (s->mixer_regs[0x82] & 2) {
             ack = 1;
         retval = 0xff;
         if (s->mixer_regs[0x82] & 2) {
             ack = 1;

-            s->mixer_regs[0x82] &= 2;
+            s->mixer_regs[0x82] &= ~2;

             qemu_irq_lower (s->pic);
         }
         break;
             qemu_irq_lower (s->pic);
         }
         break;


@@ -1058,14 +1066,14 @@ static void reset_mixer (SB16State *s)
     }
 }
 
     }
 }
 

-static IO_WRITE_PROTO (mixer_write_indexb)
+static void mixer_write_indexb(void *opaque, uint32_t nport, uint32_t val)

 {
     SB16State *s = opaque;
     (void) nport;
     s->mixer_nreg = val;
 }
 
 {
     SB16State *s = opaque;
     (void) nport;
     s->mixer_nreg = val;
 }
 

-static IO_WRITE_PROTO (mixer_write_datab)
+static void mixer_write_datab(void *opaque, uint32_t nport, uint32_t val)

 {
     SB16State *s = opaque;
 
 {
     SB16State *s = opaque;
 


@@ -1094,10 +1102,9 @@ static IO_WRITE_PROTO (mixer_write_datab)
             dma = ctz32 (val & 0xf);
             hdma = ctz32 (val & 0xf0);
             if (dma != s->dma || hdma != s->hdma) {
             dma = ctz32 (val & 0xf);
             hdma = ctz32 (val & 0xf0);
             if (dma != s->dma || hdma != s->hdma) {

-                dolog (
-                    "attempt to change DMA "
-                    "8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
-                    dma, s->dma, hdma, s->hdma, val);
+                qemu_log_mask(LOG_GUEST_ERROR, "attempt to change DMA 8bit"
+                              " %d(%d), 16bit %d(%d) (val=%#x)\n", dma, s->dma,
+                              hdma, s->hdma, val);

             }
 #if 0
             s->dma = dma;
             }
 #if 0
             s->dma = dma;


@@ -1107,8 +1114,8 @@ static IO_WRITE_PROTO (mixer_write_datab)
         break;
 
     case 0x82:
         break;
 
     case 0x82:

-        dolog ("attempt to write into IRQ status register (val=%#x)\n",
-               val);
+        qemu_log_mask(LOG_GUEST_ERROR, "attempt to write into IRQ status"
+                      " register (val=%#x)\n", val);

         return;
 
     default:
         return;
 
     default:


@@ -1121,13 +1128,7 @@ static IO_WRITE_PROTO (mixer_write_datab)
     s->mixer_regs[s->mixer_nreg] = val;
 }
 
     s->mixer_regs[s->mixer_nreg] = val;
 }
 

-static IO_WRITE_PROTO (mixer_write_indexw)
-{
-    mixer_write_indexb (opaque, nport, val & 0xff);
-    mixer_write_datab (opaque, nport, (val >> 8) & 0xff);
-}
-
-static IO_READ_PROTO (mixer_read)
+static uint32_t mixer_read(void *opaque, uint32_t nport)

 {
     SB16State *s = opaque;
 
 {
     SB16State *s = opaque;
 


@@ -1147,6 +1148,8 @@ static IO_READ_PROTO (mixer_read)
 static int write_audio (SB16State *s, int nchan, int dma_pos,
                         int dma_len, int len)
 {
 static int write_audio (SB16State *s, int nchan, int dma_pos,
                         int dma_len, int len)
 {

+    IsaDma *isa_dma = nchan == s->dma ? s->isa_dma : s->isa_hdma;
+    IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma);

     int temp, net;
     uint8_t tmpbuf[4096];
 
     int temp, net;
     uint8_t tmpbuf[4096];
 


@@ -1163,7 +1166,7 @@ static int write_audio (SB16State *s, int nchan, int dma_pos,
             to_copy = sizeof (tmpbuf);
         }
 
             to_copy = sizeof (tmpbuf);
         }
 

-        copied = DMA_read_memory (nchan, tmpbuf, dma_pos, to_copy);
+        copied = k->read_memory(isa_dma, nchan, tmpbuf, dma_pos, to_copy);

         copied = AUD_write (s->voice, tmpbuf, copied);
 
         temp -= copied;
         copied = AUD_write (s->voice, tmpbuf, copied);
 
         temp -= copied;


@@ -1184,8 +1187,9 @@ static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
     int till, copy, written, free;
 
     if (s->block_size <= 0) {
     int till, copy, written, free;
 
     if (s->block_size <= 0) {

-        dolog ("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
-               s->block_size, nchan, dma_pos, dma_len);
+        qemu_log_mask(LOG_GUEST_ERROR, "invalid block size=%d nchan=%d"
+                      " dma_pos=%d dma_len=%d\n", s->block_size, nchan,
+                      dma_pos, dma_len);

         return dma_pos;
     }
 
         return dma_pos;
     }
 


@@ -1212,7 +1216,7 @@ static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
 #endif
 
     if (till <= copy) {
 #endif
 
     if (till <= copy) {

-        if (0 == s->dma_auto) {
+        if (s->dma_auto == 0) {

             copy = till;
         }
     }
             copy = till;
         }
     }


@@ -1224,7 +1228,7 @@ static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
     if (s->left_till_irq <= 0) {
         s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1;
         qemu_irq_raise (s->pic);
     if (s->left_till_irq <= 0) {
         s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1;
         qemu_irq_raise (s->pic);

-        if (0 == s->dma_auto) {
+        if (s->dma_auto == 0) {

             control (s, 0);
             speaker (s, 0);
         }
             control (s, 0);
             speaker (s, 0);
         }


@@ -1289,9 +1293,8 @@ static const VMStateDescription vmstate_sb16 = {
     .name = "sb16",
     .version_id = 1,
     .minimum_version_id = 1,
     .name = "sb16",
     .version_id = 1,
     .minimum_version_id = 1,

-    .minimum_version_id_old = 1,

     .post_load = sb16_post_load,
     .post_load = sb16_post_load,

-    .fields      = (VMStateField []) {
+    .fields = (VMStateField[]) {

         VMSTATE_UINT32 (irq, SB16State),
         VMSTATE_UINT32 (dma, SB16State),
         VMSTATE_UINT32 (hdma, SB16State),
         VMSTATE_UINT32 (irq, SB16State),
         VMSTATE_UINT32 (dma, SB16State),
         VMSTATE_UINT32 (hdma, SB16State),


@@ -1346,7 +1349,6 @@ static const VMStateDescription vmstate_sb16 = {
 
 static const MemoryRegionPortio sb16_ioport_list[] = {
     {  4, 1, 1, .write = mixer_write_indexb },
 
 static const MemoryRegionPortio sb16_ioport_list[] = {
     {  4, 1, 1, .write = mixer_write_indexb },

-    {  4, 1, 2, .write = mixer_write_indexw },

     {  5, 1, 1, .read = mixer_read, .write = mixer_write_datab },
     {  6, 1, 1, .read = dsp_read, .write = dsp_write },
     { 10, 1, 1, .read = dsp_read },
     {  5, 1, 1, .read = mixer_read, .write = mixer_write_datab },
     {  6, 1, 1, .read = dsp_read, .write = dsp_write },
     { 10, 1, 1, .read = dsp_read },


@@ -1367,6 +1369,7 @@ static void sb16_realizefn (DeviceState *dev, Error **errp)
 {
     ISADevice *isadev = ISA_DEVICE (dev);
     SB16State *s = SB16 (dev);
 {
     ISADevice *isadev = ISA_DEVICE (dev);
     SB16State *s = SB16 (dev);

+    IsaDmaClass *k;

 
     isa_init_irq (isadev, &s->pic, s->irq);
 
 
     isa_init_irq (isadev, &s->pic, s->irq);
 


@@ -1380,13 +1383,20 @@ static void sb16_realizefn (DeviceState *dev, Error **errp)
     reset_mixer (s);
     s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
     if (!s->aux_ts) {
     reset_mixer (s);
     s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
     if (!s->aux_ts) {

-        dolog ("warning: Could not create auxiliary timer\n");
+        error_setg(errp, "warning: Could not create auxiliary timer");

     }
 
     }
 

-    isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
+    isa_register_portio_list(isadev, &s->portio_list, s->port,
+                             sb16_ioport_list, s, "sb16");
+
+    s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);
+    k = ISADMA_GET_CLASS(s->isa_hdma);
+    k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);
+
+    s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);
+    k = ISADMA_GET_CLASS(s->isa_dma);
+    k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);

 
 

-    DMA_register_channel (s->hdma, SB_read_DMA, s);
-    DMA_register_channel (s->dma, SB_read_DMA, s);

     s->can_write = 1;
 
     AUD_register_card ("sb16", &s->card);
     s->can_write = 1;
 
     AUD_register_card ("sb16", &s->card);