Changeset 44632 in vbox for trunk/src/VBox/Devices

Timestamp:

Feb 11, 2013 12:52:40 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

83720

Message:

DevIchAc97.cpp: s, d and r variable/parameter cleanups.

File:

• trunk/src/VBox/Devices/Audio/DevIchAc97.cpp (modified) (66 diffs)

trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

@@ -185 +185 @@
     BD       bd;
 } AC97BusMasterRegs;
-
-typedef struct AC97LinkState
+/** Pointer to a AC97 bus master register. */
+typedef AC97BusMasterRegs *PAC97BMREG;
+
+typedef struct AC97STATE
 {
     /** The PCI device state. */
@@ -222 +224 @@
     /** Base port of the I/O space region. */
     RTIOPORT                IOPortBase[2];
-} AC97LinkState;
+} AC97STATE;
+/** Pointer to the AC97 device state. */
+typedef AC97STATE *PAC97STATE;
 
 #define ICHAC97STATE_2_DEVINS(a_pAC97)   ((a_pAC97)->pDevIns)
-#define PCIDEV_2_ICHAC97STATE(a_pPciDev) ((AC97LinkState *)(a_pPciDev))
 
 enum
@@ -269 +272 @@
 static void mc_callback(void *opaque, int avail);
 
-static void warm_reset(AC97LinkState *s)
-{
-    NOREF(s);
-}
-
-static void cold_reset(AC97LinkState * s)
-{
-    NOREF(s);
+static void warm_reset(PAC97STATE pThis)
+{
+    NOREF(pThis);
+}
+
+static void cold_reset(PAC97STATE pThis)
+{
+    NOREF(pThis);
 }
 
 /** Fetch Buffer Descriptor at _CIV */
-static void fetch_bd(AC97LinkState *s, AC97BusMasterRegs *r)
-{
-    PPDMDEVINS pDevIns = ICHAC97STATE_2_DEVINS(s);
+static void fetch_bd(PAC97STATE pThis, PAC97BMREG pReg)
+{
+    PPDMDEVINS pDevIns = ICHAC97STATE_2_DEVINS(pThis);
     uint8_t b[8];
 
-    PDMDevHlpPhysRead(pDevIns, r->bdbar + r->civ * 8, b, sizeof(b));
-    r->bd_valid   = 1;
+    PDMDevHlpPhysRead(pDevIns, pReg->bdbar + pReg->civ * 8, b, sizeof(b));
+    pReg->bd_valid   = 1;
 #if !defined(RT_ARCH_X86) && !defined(RT_ARCH_AMD64)
 # error Please adapt the code (audio buffers are little endian)!
 #else
-    r->bd.addr    = (*(uint32_t *) &b[0]) & ~3;
-    r->bd.ctl_len = (*(uint32_t *) &b[4]);
+    pReg->bd.addr    = (*(uint32_t *) &b[0]) & ~3;
+    pReg->bd.ctl_len = (*(uint32_t *) &b[4]);
 #endif
-    r->picb       = r->bd.ctl_len & 0xffff;
+    pReg->picb       = pReg->bd.ctl_len & 0xffff;
     Log(("ac97: bd %2d addr=%#x ctl=%#06x len=%#x(%d bytes)\n",
-          r->civ, r->bd.addr, r->bd.ctl_len >> 16,
-          r->bd.ctl_len & 0xffff, (r->bd.ctl_len & 0xffff) << 1));
+         pReg->civ, pReg->bd.addr, pReg->bd.ctl_len >> 16,
+         pReg->bd.ctl_len & 0xffff, (pReg->bd.ctl_len & 0xffff) << 1));
 }
 
@@ -302 +305 @@
  * Update the BM status register
  */
-static void update_sr(AC97LinkState *s, AC97BusMasterRegs *r, uint32_t new_sr)
-{
-    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(s);
+static void update_sr(PAC97STATE pThis, PAC97BMREG pReg, uint32_t new_sr)
+{
+    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
     int event = 0;
     int level = 0;
     uint32_t new_mask = new_sr & SR_INT_MASK;
-    uint32_t old_mask = r->sr  & SR_INT_MASK;
+    uint32_t old_mask = pReg->sr  & SR_INT_MASK;
     static uint32_t const masks[] = { GS_PIINT, GS_POINT, GS_MINT };
 
@@ -319 +322 @@
             level = 0;
         }
-        else if ((new_mask & SR_LVBCI) && (r->cr & CR_LVBIE))
+        else if ((new_mask & SR_LVBCI) && (pReg->cr & CR_LVBIE))
         {
             event = 1;
             level = 1;
         }
-        else if ((new_mask & SR_BCIS) && (r->cr & CR_IOCE))
+        else if ((new_mask & SR_BCIS) && (pReg->cr & CR_IOCE))
         {
             event = 1;
@@ -331 +334 @@
     }
 
-    r->sr = new_sr;
+    pReg->sr = new_sr;
 
     Log(("ac97: IOC%d LVB%d sr=%#x event=%d level=%d\n",
-         r->sr & SR_BCIS, r->sr & SR_LVBCI, r->sr, event, level));
+         pReg->sr & SR_BCIS, pReg->sr & SR_LVBCI, pReg->sr, event, level));
 
     if (event)
     {
         if (level)
-            s->glob_sta |= masks[r - s->bm_regs];
+            pThis->glob_sta |= masks[pReg - pThis->bm_regs];
         else
-            s->glob_sta &= ~masks[r - s->bm_regs];
+            pThis->glob_sta &= ~masks[pReg - pThis->bm_regs];
 
         Log(("ac97: set irq level=%d\n", !!level));
@@ -348 +351 @@
 }
 
-static void voice_set_active(AC97LinkState *s, int bm_index, int on)
+static void voice_set_active(PAC97STATE pThis, int bm_index, int on)
 {
     switch (bm_index)
     {
-        case PI_INDEX: AUD_set_active_in( s->voice_pi, on); break;
-        case PO_INDEX: AUD_set_active_out(s->voice_po, on); break;
-        case MC_INDEX: AUD_set_active_in( s->voice_mc, on); break;
+        case PI_INDEX: AUD_set_active_in( pThis->voice_pi, on); break;
+        case PO_INDEX: AUD_set_active_out(pThis->voice_po, on); break;
+        case MC_INDEX: AUD_set_active_in( pThis->voice_mc, on); break;
         default:       AssertFailed (); break;
     }
 }
 
-static void reset_bm_regs(AC97LinkState *s, AC97BusMasterRegs *r)
+static void reset_bm_regs(PAC97STATE pThis, PAC97BMREG pReg)
 {
     Log(("ac97: reset_bm_regs\n"));
-    r->bdbar    = 0;
-    r->civ      = 0;
-    r->lvi      = 0;
+    pReg->bdbar    = 0;
+    pReg->civ      = 0;
+    pReg->lvi      = 0;
     /** @todo do we need to do that? */
-    update_sr(s, r, SR_DCH);
-    r->picb     = 0;
-    r->piv      = 0;
-    r->cr       = r->cr & CR_DONT_CLEAR_MASK;
-    r->bd_valid = 0;
-
-    voice_set_active(s, r - s->bm_regs, 0);
-    memset(s->silence, 0, sizeof(s->silence));
-}
-
-static void mixer_store(AC97LinkState *s, uint32_t i, uint16_t v)
-{
-    if (i + 2 > sizeof(s->mixer_data))
-    {
-        Log(("ac97: mixer_store: index %d out of bounds %d\n", i, sizeof(s->mixer_data)));
+    update_sr(pThis, pReg, SR_DCH);
+    pReg->picb     = 0;
+    pReg->piv      = 0;
+    pReg->cr       = pReg->cr & CR_DONT_CLEAR_MASK;
+    pReg->bd_valid = 0;
+
+    voice_set_active(pThis, pReg - pThis->bm_regs, 0);
+    memset(pThis->silence, 0, sizeof(pThis->silence));
+}
+
+static void mixer_store(PAC97STATE pThis, uint32_t i, uint16_t v)
+{
+    if (i + 2 > sizeof(pThis->mixer_data))
+    {
+        Log(("ac97: mixer_store: index %d out of bounds %d\n", i, sizeof(pThis->mixer_data)));
         return;
     }
 
-    s->mixer_data[i + 0] = v & 0xff;
-    s->mixer_data[i + 1] = v >> 8;
-}
-
-static uint16_t mixer_load(AC97LinkState *s, uint32_t i)
+    pThis->mixer_data[i + 0] = v & 0xff;
+    pThis->mixer_data[i + 1] = v >> 8;
+}
+
+static uint16_t mixer_load(PAC97STATE pThis, uint32_t i)
 {
     uint16_t val;
 
-    if (i + 2 > sizeof(s->mixer_data))
-    {
-        Log(("ac97: mixer_store: index %d out of bounds %d\n", i, sizeof(s->mixer_data)));
+    if (i + 2 > sizeof(pThis->mixer_data))
+    {
+        Log(("ac97: mixer_store: index %d out of bounds %d\n", i, sizeof(pThis->mixer_data)));
         val = 0xffff;
     }
     else
-        val = s->mixer_data[i + 0] | (s->mixer_data[i + 1] << 8);
+        val = pThis->mixer_data[i + 0] | (pThis->mixer_data[i + 1] << 8);
 
     return val;
 }
 
-static void open_voice(AC97LinkState *s, int index, int freq)
+static void open_voice(PAC97STATE pThis, int index, int freq)
 {
     audsettings_t as;
@@ -417 +420 @@
         {
             case PI_INDEX: /* PCM in */
-                s->voice_pi = AUD_open_in(&s->card, s->voice_pi, "ac97.pi", s, pi_callback, &as);
+                pThis->voice_pi = AUD_open_in(&pThis->card, pThis->voice_pi, "ac97.pi", pThis, pi_callback, &as);
 #ifdef LOG_VOICES
-                LogRel(("AC97: open PI freq=%d (%s)\n", freq, s->voice_pi ? "ok" : "FAIL"));
+                LogRel(("AC97: open PI freq=%d (%s)\n", freq, pThis->voice_pi ? "ok" : "FAIL"));
 #endif
                 break;
 
             case PO_INDEX: /* PCM out */
-                s->voice_po = AUD_open_out(&s->card, s->voice_po, "ac97.po", s, po_callback, &as);
+                pThis->voice_po = AUD_open_out(&pThis->card, pThis->voice_po, "ac97.po", pThis, po_callback, &as);
 #ifdef LOG_VOICES
-                LogRel(("AC97: open PO freq=%d (%s)\n", freq, s->voice_po ? "ok" : "FAIL"));
+                LogRel(("AC97: open PO freq=%d (%s)\n", freq, pThis->voice_po ? "ok" : "FAIL"));
 #endif
                 break;
 
             case MC_INDEX: /* Mic in */
-                s->voice_mc = AUD_open_in(&s->card, s->voice_mc, "ac97.mc", s, mc_callback, &as);
+                pThis->voice_mc = AUD_open_in(&pThis->card, pThis->voice_mc, "ac97.mc", pThis, mc_callback, &as);
 #ifdef LOG_VOICES
-                LogRel(("AC97: open MC freq=%d (%s)\n", freq, s->voice_mc ? "ok" : "FAIL"));
+                LogRel(("AC97: open MC freq=%d (%s)\n", freq, pThis->voice_mc ? "ok" : "FAIL"));
 #endif
                 break;
@@ -443 +446 @@
         {
             case PI_INDEX:
-                AUD_close_in(&s->card, s->voice_pi);
+                AUD_close_in(&pThis->card, pThis->voice_pi);
 #ifdef LOG_VOICES
                 LogRel(("AC97: Closing PCM IN\n"));
 #endif
-                s->voice_pi = NULL;
+                pThis->voice_pi = NULL;
                 break;
 
             case PO_INDEX:
-                AUD_close_out(&s->card, s->voice_po);
+                AUD_close_out(&pThis->card, pThis->voice_po);
 #ifdef LOG_VOICES
                 LogRel(("AC97: Closing PCM OUT\n"));
 #endif
-                s->voice_po = NULL;
+                pThis->voice_po = NULL;
                 break;
 
             case MC_INDEX:
-                AUD_close_in(&s->card, s->voice_mc);
+                AUD_close_in(&pThis->card, pThis->voice_mc);
 #ifdef LOG_VOICES
                 LogRel(("AC97: Closing MIC IN\n"));
 #endif
-                s->voice_mc = NULL;
+                pThis->voice_mc = NULL;
                 break;
         }
@@ -469 +472 @@
 }
 
-static void reset_voices(AC97LinkState *s, uint8_t active[LAST_INDEX])
+static void reset_voices(PAC97STATE pThis, uint8_t active[LAST_INDEX])
 {
     uint16_t freq;
 
-    freq = mixer_load(s, AC97_PCM_LR_ADC_Rate);
-    open_voice(s, PI_INDEX, freq);
-    AUD_set_active_in(s->voice_pi, active[PI_INDEX]);
-
-    freq = mixer_load(s, AC97_PCM_Front_DAC_Rate);
-    open_voice(s, PO_INDEX, freq);
-    AUD_set_active_out (s->voice_po, active[PO_INDEX]);
-
-    freq = mixer_load(s, AC97_MIC_ADC_Rate);
-    open_voice(s, MC_INDEX, freq);
-    AUD_set_active_in(s->voice_mc, active[MC_INDEX]);
+    freq = mixer_load(pThis, AC97_PCM_LR_ADC_Rate);
+    open_voice(pThis, PI_INDEX, freq);
+    AUD_set_active_in(pThis->voice_pi, active[PI_INDEX]);
+
+    freq = mixer_load(pThis, AC97_PCM_Front_DAC_Rate);
+    open_voice(pThis, PO_INDEX, freq);
+    AUD_set_active_out(pThis->voice_po, active[PO_INDEX]);
+
+    freq = mixer_load(pThis, AC97_MIC_ADC_Rate);
+    open_voice(pThis, MC_INDEX, freq);
+    AUD_set_active_in(pThis->voice_mc, active[MC_INDEX]);
 }
 
 #ifdef USE_MIXER
 
-static void set_volume(AC97LinkState *s, int index, audmixerctl_t mt, uint32_t val)
+static void set_volume(PAC97STATE pThis, int index, audmixerctl_t mt, uint32_t val)
 {
     int mute = (val >> MUTE_SHIFT) & 1;
@@ -498 +501 @@
 # ifdef SOFT_VOLUME
     if (index == AC97_Master_Volume_Mute)
-        AUD_set_volume_out(s->voice_po, mute, lvol, rvol);
+        AUD_set_volume_out(pThis->voice_po, mute, lvol, rvol);
     else
         AUD_set_volume(mt, &mute, &lvol, &rvol);
@@ -521 +524 @@
         val |= RT_BIT(12) | RT_BIT(11) | RT_BIT(10) | RT_BIT(9) | RT_BIT(8);
 
-    mixer_store(s, index, val);
+    mixer_store(pThis, index, val);
 }
 
@@ -556 +559 @@
 }
 
-static void record_select(AC97LinkState *s, uint32_t val)
+static void record_select(PAC97STATE pThis, uint32_t val)
 {
     uint8_t rs = val & REC_MASK;
@@ -565 +568 @@
     rs = aud_to_ac97_record_source(ars);
     ls = aud_to_ac97_record_source(als);
-    mixer_store(s, AC97_Record_Select, rs | (ls << 8));
+    mixer_store(pThis, AC97_Record_Select, rs | (ls << 8));
 }
 
 #endif /* USE_MIXER */
 
-static void mixer_reset(AC97LinkState *s)
+static void mixer_reset(PAC97STATE pThis)
 {
     uint8_t active[LAST_INDEX];
 
     Log(("ac97: mixer_reset\n"));
-    memset(s->mixer_data, 0, sizeof(s->mixer_data));
+    memset(pThis->mixer_data, 0, sizeof(pThis->mixer_data));
     memset(active, 0, sizeof(active));
-    mixer_store(s, AC97_Reset                   , 0x0000); /* 6940 */
-    mixer_store(s, AC97_Master_Volume_Mono_Mute , 0x8000);
-    mixer_store(s, AC97_PC_BEEP_Volume_Mute     , 0x0000);
-
-    mixer_store(s, AC97_Phone_Volume_Mute       , 0x8008);
-    mixer_store(s, AC97_Mic_Volume_Mute         , 0x8008);
-    mixer_store(s, AC97_CD_Volume_Mute          , 0x8808);
-    mixer_store(s, AC97_Aux_Volume_Mute         , 0x8808);
-    mixer_store(s, AC97_Record_Gain_Mic_Mute    , 0x8000);
-    mixer_store(s, AC97_General_Purpose         , 0x0000);
-    mixer_store(s, AC97_3D_Control              , 0x0000);
-    mixer_store(s, AC97_Powerdown_Ctrl_Stat     , 0x000f);
+    mixer_store(pThis, AC97_Reset                   , 0x0000); /* 6940 */
+    mixer_store(pThis, AC97_Master_Volume_Mono_Mute , 0x8000);
+    mixer_store(pThis, AC97_PC_BEEP_Volume_Mute     , 0x0000);
+
+    mixer_store(pThis, AC97_Phone_Volume_Mute       , 0x8008);
+    mixer_store(pThis, AC97_Mic_Volume_Mute         , 0x8008);
+    mixer_store(pThis, AC97_CD_Volume_Mute          , 0x8808);
+    mixer_store(pThis, AC97_Aux_Volume_Mute         , 0x8808);
+    mixer_store(pThis, AC97_Record_Gain_Mic_Mute    , 0x8000);
+    mixer_store(pThis, AC97_General_Purpose         , 0x0000);
+    mixer_store(pThis, AC97_3D_Control              , 0x0000);
+    mixer_store(pThis, AC97_Powerdown_Ctrl_Stat     , 0x000f);
 
     /*
      * Sigmatel 9700 (STAC9700)
      */
-    mixer_store(s, AC97_Vendor_ID1              , 0x8384);
-    mixer_store(s, AC97_Vendor_ID2              , 0x7600); /* 7608 */
-
-    mixer_store(s, AC97_Extended_Audio_ID       , 0x0809);
-    mixer_store(s, AC97_Extended_Audio_Ctrl_Stat, 0x0009);
-    mixer_store(s, AC97_PCM_Front_DAC_Rate      , 0xbb80);
-    mixer_store(s, AC97_PCM_Surround_DAC_Rate   , 0xbb80);
-    mixer_store(s, AC97_PCM_LFE_DAC_Rate        , 0xbb80);
-    mixer_store(s, AC97_PCM_LR_ADC_Rate         , 0xbb80);
-    mixer_store(s, AC97_MIC_ADC_Rate            , 0xbb80);
+    mixer_store(pThis, AC97_Vendor_ID1              , 0x8384);
+    mixer_store(pThis, AC97_Vendor_ID2              , 0x7600); /* 7608 */
+
+    mixer_store(pThis, AC97_Extended_Audio_ID       , 0x0809);
+    mixer_store(pThis, AC97_Extended_Audio_Ctrl_Stat, 0x0009);
+    mixer_store(pThis, AC97_PCM_Front_DAC_Rate      , 0xbb80);
+    mixer_store(pThis, AC97_PCM_Surround_DAC_Rate   , 0xbb80);
+    mixer_store(pThis, AC97_PCM_LFE_DAC_Rate        , 0xbb80);
+    mixer_store(pThis, AC97_PCM_LR_ADC_Rate         , 0xbb80);
+    mixer_store(pThis, AC97_MIC_ADC_Rate            , 0xbb80);
 
 #ifdef USE_MIXER
-    record_select(s, 0);
-    set_volume(s, AC97_Master_Volume_Mute,  AUD_MIXER_VOLUME,  0x8000);
-    set_volume(s, AC97_PCM_Out_Volume_Mute, AUD_MIXER_PCM,     0x8808);
-    set_volume(s, AC97_Line_In_Volume_Mute, AUD_MIXER_LINE_IN, 0x8808);
+    record_select(pThis, 0);
+    set_volume(pThis, AC97_Master_Volume_Mute,  AUD_MIXER_VOLUME,  0x8000);
+    set_volume(pThis, AC97_PCM_Out_Volume_Mute, AUD_MIXER_PCM,     0x8808);
+    set_volume(pThis, AC97_Line_In_Volume_Mute, AUD_MIXER_LINE_IN, 0x8808);
 #else
-    mixer_store(s, AC97_Record_Select, 0);
-    mixer_store(s, AC97_Master_Volume_Mute,  0x8000);
-    mixer_store(s, AC97_PCM_Out_Volume_Mute, 0x8808);
-    mixer_store(s, AC97_Line_In_Volume_Mute, 0x8808);
+    mixer_store(pThis, AC97_Record_Select, 0);
+    mixer_store(pThis, AC97_Master_Volume_Mute,  0x8000);
+    mixer_store(pThis, AC97_PCM_Out_Volume_Mute, 0x8808);
+    mixer_store(pThis, AC97_Line_In_Volume_Mute, 0x8808);
 #endif
 
-    reset_voices(s, active);
-}
-
-static int write_audio(AC97LinkState *s, AC97BusMasterRegs *r, int max, int *stop)
-{
-    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(s);
+    reset_voices(pThis, active);
+}
+
+static int write_audio(PAC97STATE pThis, PAC97BMREG pReg, int max, int *stop)
+{
+    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
     uint8_t     tmpbuf[4096];
-    uint32_t    addr = r->bd.addr;
-    uint32_t    temp = r->picb << 1;
+    uint32_t    addr = pReg->bd.addr;
+    uint32_t    temp = pReg->picb << 1;
     uint32_t    written = 0;
     int         to_copy = 0;
@@ -640 +643 @@
         to_copy = audio_MIN(temp, sizeof(tmpbuf));
         PDMDevHlpPhysRead(pDevIns, addr, tmpbuf, to_copy);
-        copied = AUD_write(s->voice_po, tmpbuf, to_copy);
+        copied = AUD_write(pThis->voice_po, tmpbuf, to_copy);
         Log(("ac97: write_audio max=%x to_copy=%x copied=%x\n", max, to_copy, copied));
         if (!copied)
@@ -657 +660 @@
         {
             Log(("ac97: whoops\n"));
-            s->last_samp = 0;
+            pThis->last_samp = 0;
         }
         else
-            s->last_samp = *(uint32_t *) &tmpbuf[to_copy - 4];
-    }
-
-    r->bd.addr = addr;
+            pThis->last_samp = *(uint32_t *)&tmpbuf[to_copy - 4];
+    }
+
+    pReg->bd.addr = addr;
     return written;
 }
 
-static void write_bup(AC97LinkState *s, int elapsed)
+static void write_bup(PAC97STATE pThis, int elapsed)
 {
     int written = 0;
 
     Log(("ac97: write_bup\n"));
-    if (!(s->bup_flag & BUP_SET))
-    {
-        if (s->bup_flag & BUP_LAST)
+    if (!(pThis->bup_flag & BUP_SET))
+    {
+        if (pThis->bup_flag & BUP_LAST)
         {
             unsigned int i;
-            uint32_t *p = (uint32_t*)s->silence;
-            for (i = 0; i < sizeof(s->silence) / 4; i++)
-                *p++ = s->last_samp;
+            uint32_t *p = (uint32_t*)pThis->silence;
+            for (i = 0; i < sizeof(pThis->silence) / 4; i++)
+                *p++ = pThis->last_samp;
         }
         else
-            memset(s->silence, 0, sizeof(s->silence));
-
-        s->bup_flag |= BUP_SET;
+            memset(pThis->silence, 0, sizeof(pThis->silence));
+
+        pThis->bup_flag |= BUP_SET;
     }
 
     while (elapsed)
     {
-        unsigned int temp = audio_MIN((unsigned int)elapsed, sizeof(s->silence));
+        unsigned int temp = audio_MIN((unsigned int)elapsed, sizeof(pThis->silence));
         while (temp)
         {
-            int copied = AUD_write(s->voice_po, s->silence, temp);
+            int copied = AUD_write(pThis->voice_po, pThis->silence, temp);
             if (!copied)
                 return;
@@ -702 +705 @@
 }
 
-static int read_audio(AC97LinkState *s, AC97BusMasterRegs *r, int max, int *stop)
-{
-    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(s);
+static int read_audio(PAC97STATE pThis, PAC97BMREG pReg, int max, int *stop)
+{
+    PPDMDEVINS  pDevIns = ICHAC97STATE_2_DEVINS(pThis);
     uint8_t     tmpbuf[4096];
-    uint32_t    addr = r->bd.addr;
-    uint32_t    temp = r->picb << 1;
+    uint32_t    addr = pReg->bd.addr;
+    uint32_t    temp = pReg->picb << 1;
     uint32_t    nread = 0;
     int         to_copy = 0;
-    SWVoiceIn  *voice = (r - s->bm_regs) == MC_INDEX ? s->voice_mc : s->voice_pi;
+    SWVoiceIn  *voice = (pReg - pThis->bm_regs) == MC_INDEX ? pThis->voice_mc : pThis->voice_pi;
 
     temp = audio_MIN(temp, (uint32_t)max);
@@ -735 +738 @@
     }
 
-    r->bd.addr = addr;
+    pReg->bd.addr = addr;
     return nread;
 }
 
-static void transfer_audio(AC97LinkState *s, int index, int elapsed)
-{
-    AC97BusMasterRegs *r = &s->bm_regs[index];
-    int written = 0, stop = 0;
-
-    if (r->sr & SR_DCH)
-    {
-        if (r->cr & CR_RPBM)
+static void transfer_audio(PAC97STATE pThis, int index, int elapsed)
+{
+    PAC97BMREG pReg = &pThis->bm_regs[index];
+    int written = 0;
+    int stop = 0;
+
+    if (pReg->sr & SR_DCH)
+    {
+        if (pReg->cr & CR_RPBM)
         {
             switch (index)
             {
                 case PO_INDEX:
-                    write_bup(s, elapsed);
+                    write_bup(pThis, elapsed);
                     break;
             }
@@ -762 +766 @@
         int temp;
 
-        if (!r->bd_valid)
+        if (!pReg->bd_valid)
         {
             Log(("ac97: invalid bd\n"));
-            fetch_bd(s, r);
-        }
-
-        if (!r->picb)
-        {
-            Log(("ac97: fresh bd %d is empty %#x %#x, skipping\n", r->civ, r->bd.addr, r->bd.ctl_len));
-            if (r->civ == r->lvi)
+            fetch_bd(pThis, pReg);
+        }
+
+        if (!pReg->picb)
+        {
+            Log(("ac97: fresh bd %d is empty %#x %#x, skipping\n", pReg->civ, pReg->bd.addr, pReg->bd.ctl_len));
+            if (pReg->civ == pReg->lvi)
             {
-                r->sr |= SR_DCH; /* CELV? */
-                s->bup_flag = 0;
+                pReg->sr |= SR_DCH; /* CELV? */
+                pThis->bup_flag = 0;
                 break;
             }
-            r->sr &= ~SR_CELV;
-            r->civ = r->piv;
-            r->piv = (r->piv + 1) % 32;
-            fetch_bd(s, r);
+            pReg->sr &= ~SR_CELV;
+            pReg->civ = pReg->piv;
+            pReg->piv = (pReg->piv + 1) % 32;
+            fetch_bd(pThis, pReg);
             continue;
         }
@@ -787 +791 @@
         {
             case PO_INDEX:
-                temp = write_audio(s, r, elapsed, &stop);
+                temp = write_audio(pThis, pReg, elapsed, &stop);
                 written += temp;
                 elapsed -= temp;
                 Assert((temp & 1) == 0);    /* Else the following shift won't work */
-                r->picb -= (temp >> 1);
+                pReg->picb -= (temp >> 1);
                 break;
 
             case PI_INDEX:
             case MC_INDEX:
-                temp = read_audio(s, r, elapsed, &stop);
+                temp = read_audio(pThis, pReg, elapsed, &stop);
                 elapsed -= temp;
                 Assert((temp & 1) == 0);    /* Else the following shift won't work */
-                r->picb -= (temp >> 1);
+                pReg->picb -= (temp >> 1);
                 break;
         }
 
-        Log(("r->picb = %d\n", r->picb));
-
-        if (!r->picb)
-        {
-            uint32_t new_sr = r->sr & ~SR_CELV;
-
-            if (r->bd.ctl_len & BD_IOC)
+        Log(("pReg->picb = %d\n", pReg->picb));
+
+        if (!pReg->picb)
+        {
+            uint32_t new_sr = pReg->sr & ~SR_CELV;
+
+            if (pReg->bd.ctl_len & BD_IOC)
                 new_sr |= SR_BCIS;
 
-            if (r->civ == r->lvi)
+            if (pReg->civ == pReg->lvi)
             {
-                Log(("ac97: Underrun civ (%d) == lvi (%d)\n", r->civ, r->lvi));
+                Log(("ac97: Underrun civ (%d) == lvi (%d)\n", pReg->civ, pReg->lvi));
                 new_sr |= SR_LVBCI | SR_DCH | SR_CELV;
                 stop = 1;
-                s->bup_flag = (r->bd.ctl_len & BD_BUP) ? BUP_LAST : 0;
+                pThis->bup_flag = (pReg->bd.ctl_len & BD_BUP) ? BUP_LAST : 0;
             }
             else
             {
-                r->civ = r->piv;
-                r->piv = (r->piv + 1) % 32;
-                fetch_bd (s, r);
+                pReg->civ = pReg->piv;
+                pReg->piv = (pReg->piv + 1) % 32;
+                fetch_bd(pThis, pReg);
             }
-            update_sr(s, r, new_sr);
+            update_sr(pThis, pReg, new_sr);
         }
     }
@@ -832 +836 @@
 static void pi_callback(void *opaque, int avail)
 {
-    transfer_audio((AC97LinkState *)opaque, PI_INDEX, avail);
+    transfer_audio((AC97STATE *)opaque, PI_INDEX, avail);
 }
 
 static void mc_callback(void *opaque, int avail)
 {
-    transfer_audio((AC97LinkState *)opaque, MC_INDEX, avail);
+    transfer_audio((AC97STATE *)opaque, MC_INDEX, avail);
 }
 
 static void po_callback(void *opaque, int free)
 {
-    transfer_audio((AC97LinkState *)opaque, PO_INDEX, free);
+    transfer_audio((AC97STATE *)opaque, PO_INDEX, free);
 }
 
@@ -850 +854 @@
 static DECLCALLBACK(int) ichac97IOPortNABMRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    AC97LinkState *d = (AC97LinkState *)pvUser;
-    AC97LinkState *s = d;
+    PAC97STATE pThis = (PAC97STATE)pvUser;
 
     switch (cb)
@@ -857 +860 @@
         case 1:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             *pu32 = ~0U;
 
@@ -865 +868 @@
                 case CAS:
                     /* Codec Access Semaphore Register */
-                    Log(("ac97: CAS %d\n", s->cas));
-                    *pu32 = s->cas;
-                    s->cas = 1;
+                    Log(("ac97: CAS %d\n", pThis->cas));
+                    *pu32 = pThis->cas;
+                    pThis->cas = 1;
                     break;
                 case PI_CIV:
@@ -873 +876 @@
                 case MC_CIV:
                     /* Current Index Value Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->civ;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->civ;
                     Log(("ac97: CIV[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -881 +884 @@
                 case MC_LVI:
                     /* Last Valid Index Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->lvi;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->lvi;
                     Log(("ac97: LVI[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -889 +892 @@
                 case MC_PIV:
                     /* Prefetched Index Value Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->piv;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->piv;
                     Log(("ac97: PIV[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -897 +900 @@
                 case MC_CR:
                     /* Control Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->cr;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->cr;
                     Log(("ac97: CR[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -905 +908 @@
                 case MC_SR:
                     /* Status Register (lower part) */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->sr & 0xff;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->sr & 0xff;
                     Log(("ac97: SRb[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -918 +921 @@
         case 2:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             *pu32 = ~0U;
 
@@ -928 +931 @@
                 case MC_SR:
                     /* Status Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->sr;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->sr;
                     Log(("ac97: SR[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -936 +939 @@
                 case MC_PICB:
                     /* Position in Current Buffer Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->picb;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->picb;
                     Log(("ac97: PICB[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -949 +952 @@
         case 4:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             *pu32 = ~0U;
 
@@ -959 +962 @@
                 case MC_BDBAR:
                     /* Buffer Descriptor Base Address Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->bdbar;
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->bdbar;
                     Log(("ac97: BMADDR[%d] -> %#x\n", GET_BM(index), *pu32));
                     break;
@@ -969 +972 @@
                      *                Last Valid Index Register +
                      *                Status Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->civ | (r->lvi << 8) | (r->sr << 16);
-                    Log(("ac97: CIV LVI SR[%d] -> %#x, %#x, %#x\n", GET_BM(index), r->civ, r->lvi, r->sr));
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->civ | (pReg->lvi << 8) | (pReg->sr << 16);
+                    Log(("ac97: CIV LVI SR[%d] -> %#x, %#x, %#x\n", GET_BM(index), pReg->civ, pReg->lvi, pReg->sr));
                     break;
                 case PI_PICB:
@@ -979 +982 @@
                      *                Prefetched Index Value Register +
                      *                Control Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    *pu32 = r->picb | (r->piv << 16) | (r->cr << 24);
-                    Log(("ac97: PICB PIV CR[%d] -> %#x %#x %#x %#x\n", GET_BM(index), *pu32, r->picb, r->piv, r->cr));
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    *pu32 = pReg->picb | (pReg->piv << 16) | (pReg->cr << 24);
+                    Log(("ac97: PICB PIV CR[%d] -> %#x %#x %#x %#x\n", GET_BM(index), *pu32, pReg->picb, pReg->piv, pReg->cr));
                     break;
                 case GLOB_CNT:
                     /* Global Control */
-                    *pu32 = s->glob_cnt;
+                    *pu32 = pThis->glob_cnt;
                     Log(("ac97: glob_cnt -> %#x\n", *pu32));
                     break;
                 case GLOB_STA:
                     /* Global Status */
-                    *pu32 = s->glob_sta | GS_S0CR;
+                    *pu32 = pThis->glob_sta | GS_S0CR;
                     Log(("ac97: glob_sta -> %#x\n", *pu32));
                     break;
@@ -1011 +1014 @@
 static DECLCALLBACK(int) ichac97IOPortNABMWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    AC97LinkState *d = (AC97LinkState *)pvUser;
-    AC97LinkState *s = d;
+    PAC97STATE pThis = (PAC97STATE)pvUser;
 
     switch (cb)
@@ -1018 +1020 @@
         case 1:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             switch (index)
             {
@@ -1026 +1028 @@
                 case MC_LVI:
                     /* Last Valid Index */
-                    r = &s->bm_regs[GET_BM(index)];
-                    if ((r->cr & CR_RPBM) && (r->sr & SR_DCH))
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    if ((pReg->cr & CR_RPBM) && (pReg->sr & SR_DCH))
                     {
-                        r->sr &= ~(SR_DCH | SR_CELV);
-                        r->civ = r->piv;
-                        r->piv = (r->piv + 1) % 32;
-                        fetch_bd (s, r);
+                        pReg->sr &= ~(SR_DCH | SR_CELV);
+                        pReg->civ = pReg->piv;
+                        pReg->piv = (pReg->piv + 1) % 32;
+                        fetch_bd(pThis, pReg);
                     }
-                    r->lvi = u32 % 32;
+                    pReg->lvi = u32 % 32;
                     Log(("ac97: LVI[%d] <- %#x\n", GET_BM(index), u32));
                     break;
@@ -1041 +1043 @@
                 case MC_CR:
                     /* Control Register */
-                    r = &s->bm_regs[GET_BM(index)];
+                    pReg = &pThis->bm_regs[GET_BM(index)];
                     if (u32 & CR_RR)
-                        reset_bm_regs(s, r);
+                        reset_bm_regs(pThis, pReg);
                     else
                     {
-                        r->cr = u32 & CR_VALID_MASK;
-                        if (!(r->cr & CR_RPBM))
+                        pReg->cr = u32 & CR_VALID_MASK;
+                        if (!(pReg->cr & CR_RPBM))
                         {
-                            voice_set_active(s, r - s->bm_regs, 0);
-                            r->sr |= SR_DCH;
+                            voice_set_active(pThis, pReg - pThis->bm_regs, 0);
+                            pReg->sr |= SR_DCH;
                         }
                         else
                         {
-                            r->civ = r->piv;
-                            r->piv = (r->piv + 1) % 32;
-                            fetch_bd(s, r);
-                            r->sr &= ~SR_DCH;
-                            voice_set_active(s, r - s->bm_regs, 1);
+                            pReg->civ = pReg->piv;
+                            pReg->piv = (pReg->piv + 1) % 32;
+                            fetch_bd(pThis, pReg);
+                            pReg->sr &= ~SR_DCH;
+                            voice_set_active(pThis, pReg - pThis->bm_regs, 1);
                         }
                     }
-                    Log(("ac97: CR[%d] <- %#x (cr %#x)\n", GET_BM(index), u32, r->cr));
+                    Log(("ac97: CR[%d] <- %#x (cr %#x)\n", GET_BM(index), u32, pReg->cr));
                     break;
                 case PI_SR:
@@ -1067 +1069 @@
                 case MC_SR:
                     /* Status Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    r->sr |= u32 & ~(SR_RO_MASK | SR_WCLEAR_MASK);
-                    update_sr(s, r, r->sr & ~(u32 & SR_WCLEAR_MASK));
-                    Log(("ac97: SR[%d] <- %#x (sr %#x)\n", GET_BM(index), u32, r->sr));
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    pReg->sr |= u32 & ~(SR_RO_MASK | SR_WCLEAR_MASK);
+                    update_sr(pThis, pReg, pReg->sr & ~(u32 & SR_WCLEAR_MASK));
+                    Log(("ac97: SR[%d] <- %#x (sr %#x)\n", GET_BM(index), u32, pReg->sr));
                     break;
                 default:
@@ -1081 +1083 @@
         case 2:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             switch (index)
             {
@@ -1089 +1091 @@
                 case MC_SR:
                     /* Status Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    r->sr |= u32 & ~(SR_RO_MASK | SR_WCLEAR_MASK);
-                    update_sr(s, r, r->sr & ~(u32 & SR_WCLEAR_MASK));
-                    Log(("ac97: SR[%d] <- %#x (sr %#x)\n", GET_BM(index), u32, r->sr));
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    pReg->sr |= u32 & ~(SR_RO_MASK | SR_WCLEAR_MASK);
+                    update_sr(pThis, pReg, pReg->sr & ~(u32 & SR_WCLEAR_MASK));
+                    Log(("ac97: SR[%d] <- %#x (sr %#x)\n", GET_BM(index), u32, pReg->sr));
                     break;
                 default:
@@ -1103 +1105 @@
         case 4:
         {
-            AC97BusMasterRegs *r = NULL;
-            uint32_t index = Port - s->IOPortBase[1];
+            PAC97BMREG pReg = NULL;
+            uint32_t index = Port - pThis->IOPortBase[1];
             switch (index)
             {
@@ -1111 +1113 @@
                 case MC_BDBAR:
                     /* Buffer Descriptor list Base Address Register */
-                    r = &s->bm_regs[GET_BM(index)];
-                    r->bdbar = u32 & ~3;
-                    Log(("ac97: BDBAR[%d] <- %#x (bdbar %#x)\n", GET_BM(index), u32, r->bdbar));
+                    pReg = &pThis->bm_regs[GET_BM(index)];
+                    pReg->bdbar = u32 & ~3;
+                    Log(("ac97: BDBAR[%d] <- %#x (bdbar %#x)\n", GET_BM(index), u32, pReg->bdbar));
                     break;
                 case GLOB_CNT:
                     /* Global Control */
                     if (u32 & GC_WR)
-                        warm_reset (s);
+                        warm_reset(pThis);
                     if (u32 & GC_CR)
-                        cold_reset (s);
+                        cold_reset(pThis);
                     if (!(u32 & (GC_WR | GC_CR)))
-                        s->glob_cnt = u32 & GC_VALID_MASK;
-                    Log(("ac97: glob_cnt <- %#x (glob_cnt %#x)\n", u32, s->glob_cnt));
+                        pThis->glob_cnt = u32 & GC_VALID_MASK;
+                    Log(("ac97: glob_cnt <- %#x (glob_cnt %#x)\n", u32, pThis->glob_cnt));
                     break;
                 case GLOB_STA:
                     /* Global Status */
-                    s->glob_sta &= ~(u32 & GS_WCLEAR_MASK);
-                    s->glob_sta |= (u32 & ~(GS_WCLEAR_MASK | GS_RO_MASK)) & GS_VALID_MASK;
-                    Log(("ac97: glob_sta <- %#x (glob_sta %#x)\n", u32, s->glob_sta));
+                    pThis->glob_sta &= ~(u32 & GS_WCLEAR_MASK);
+                    pThis->glob_sta |= (u32 & ~(GS_WCLEAR_MASK | GS_RO_MASK)) & GS_VALID_MASK;
+                    Log(("ac97: glob_sta <- %#x (glob_sta %#x)\n", u32, pThis->glob_sta));
                     break;
                 default:
@@ -1150 +1152 @@
 static DECLCALLBACK(int) ichac97IOPortNAMRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    AC97LinkState *d = (AC97LinkState *)pvUser;
-    AC97LinkState *s = d;
+    PAC97STATE pThis = (PAC97STATE)pvUser;
 
     switch (cb)
@@ -1158 +1159 @@
         {
             Log(("ac97: U nam readb %#x\n", Port));
-            s->cas = 0;
+            pThis->cas = 0;
             *pu32 = ~0U;
             break;
@@ -1165 +1166 @@
         case 2:
         {
-            uint32_t index = Port - s->IOPortBase[0];
+            uint32_t index = Port - pThis->IOPortBase[0];
             *pu32 = ~0U;
-            s->cas = 0;
+            pThis->cas = 0;
             switch (index)
             {
                 default:
-                    *pu32 = mixer_load(s, index);
+                    *pu32 = mixer_load(pThis, index);
                     Log(("ac97: nam readw %#x -> %#x\n", Port, *pu32));
                     break;
@@ -1181 +1182 @@
         {
             Log(("ac97: U nam readl %#x\n", Port));
-            s->cas = 0;
+            pThis->cas = 0;
             *pu32 = ~0U;
             break;
@@ -1197 +1198 @@
 static DECLCALLBACK(int) ichac97IOPortNAMWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    AC97LinkState *d = (AC97LinkState *)pvUser;
-    AC97LinkState *s = d;
+    PAC97STATE pThis = (PAC97STATE)pvUser;
 
     switch (cb)
@@ -1205 +1205 @@
         {
             Log(("ac97: U nam writeb %#x <- %#x\n", Port, u32));
-            s->cas = 0;
+            pThis->cas = 0;
             break;
         }
@@ -1211 +1211 @@
         case 2:
         {
-            uint32_t index = Port - s->IOPortBase[0];
-            s->cas = 0;
+            uint32_t index = Port - pThis->IOPortBase[0];
+            pThis->cas = 0;
             switch (index)
             {
                 case AC97_Reset:
-                    mixer_reset(s);
+                    mixer_reset(pThis);
                     break;
                 case AC97_Powerdown_Ctrl_Stat:
                     u32 &= ~0xf;
-                    u32 |= mixer_load(s, index) & 0xf;
-                    mixer_store(s, index, u32);
+                    u32 |= mixer_load(pThis, index) & 0xf;
+                    mixer_store(pThis, index, u32);
                     break;
 #ifdef USE_MIXER
                 case AC97_Master_Volume_Mute:
-                    set_volume(s, index, AUD_MIXER_VOLUME, u32);
+                    set_volume(pThis, index, AUD_MIXER_VOLUME, u32);
                     break;
                 case AC97_PCM_Out_Volume_Mute:
-                    set_volume(s, index, AUD_MIXER_PCM, u32);
+                    set_volume(pThis, index, AUD_MIXER_PCM, u32);
                     break;
                 case AC97_Line_In_Volume_Mute:
-                    set_volume(s, index, AUD_MIXER_LINE_IN, u32);
+                    set_volume(pThis, index, AUD_MIXER_LINE_IN, u32);
                     break;
                 case AC97_Record_Select:
-                    record_select(s, u32);
+                    record_select(pThis, u32);
                     break;
 #else  /* !USE_MIXER */
@@ -1241 +1241 @@
                 case AC97_Line_In_Volume_Mute:
                 case AC97_Record_Select:
-                    mixer_store(s, index, u32);
+                    mixer_store(pThis, index, u32);
                     break;
 #endif /* !USE_MIXER */
@@ -1254 +1254 @@
                     if (!(u32 & EACS_VRA))
                     {
-                        mixer_store(s, AC97_PCM_Front_DAC_Rate, 0xbb80);
-                        mixer_store(s, AC97_PCM_LR_ADC_Rate,    0xbb80);
-                        open_voice(s, PI_INDEX, 48000);
-                        open_voice(s, PO_INDEX, 48000);
+                        mixer_store(pThis, AC97_PCM_Front_DAC_Rate, 0xbb80);
+                        mixer_store(pThis, AC97_PCM_LR_ADC_Rate,    0xbb80);
+                        open_voice(pThis, PI_INDEX, 48000);
+                        open_voice(pThis, PO_INDEX, 48000);
                     }
                     if (!(u32 & EACS_VRM))
                     {
-                        mixer_store(s, AC97_MIC_ADC_Rate, 0xbb80);
-                        open_voice(s, MC_INDEX, 48000);
+                        mixer_store(pThis, AC97_MIC_ADC_Rate, 0xbb80);
+                        open_voice(pThis, MC_INDEX, 48000);
                     }
                     Log(("ac97: Setting extended audio control to %#x\n", u32));
-                    mixer_store(s, AC97_Extended_Audio_Ctrl_Stat, u32);
+                    mixer_store(pThis, AC97_Extended_Audio_Ctrl_Stat, u32);
                     break;
                 case AC97_PCM_Front_DAC_Rate:
-                    if (mixer_load(s, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRA)
+                    if (mixer_load(pThis, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRA)
                     {
-                        mixer_store(s, index, u32);
+                        mixer_store(pThis, index, u32);
                         Log(("ac97: Set front DAC rate to %d\n", u32));
-                        open_voice(s, PO_INDEX, u32);
+                        open_voice(pThis, PO_INDEX, u32);
                     }
                     else
@@ -1278 +1278 @@
                     break;
                 case AC97_MIC_ADC_Rate:
-                    if (mixer_load(s, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRM)
+                    if (mixer_load(pThis, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRM)
                     {
-                        mixer_store(s, index, u32);
+                        mixer_store(pThis, index, u32);
                         Log(("ac97: Set MIC ADC rate to %d\n", u32));
-                        open_voice(s, MC_INDEX, u32);
+                        open_voice(pThis, MC_INDEX, u32);
                     }
                     else
@@ -1288 +1288 @@
                     break;
                 case AC97_PCM_LR_ADC_Rate:
-                    if (mixer_load(s, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRA)
+                    if (mixer_load(pThis, AC97_Extended_Audio_Ctrl_Stat) & EACS_VRA)
                     {
-                        mixer_store(s, index, u32);
+                        mixer_store(pThis, index, u32);
                         Log(("ac97: Set front LR ADC rate to %d\n", u32));
-                        open_voice(s, PI_INDEX, u32);
+                        open_voice(pThis, PI_INDEX, u32);
                     }
                     else
@@ -1299 +1299 @@
                 default:
                     Log(("ac97: U nam writew %#x <- %#x\n", Port, u32));
-                    mixer_store(s, index, u32);
+                    mixer_store(pThis, index, u32);
                     break;
             }
@@ -1308 +1308 @@
         {
             Log(("ac97: U nam writel %#x <- %#x\n", Port, u32));
-            s->cas = 0;
+            pThis->cas = 0;
             break;
         }
@@ -1326 +1326 @@
                                           PCIADDRESSSPACE enmType)
 {
-    PPDMDEVINS          pDevIns = pPciDev->pDevIns;
-    AC97LinkState      *pThis = PCIDEV_2_ICHAC97STATE(pPciDev);
-    RTIOPORT            Port = (RTIOPORT)GCPhysAddress;
-    int                 rc;
+    PPDMDEVINS  pDevIns = pPciDev->pDevIns;
+    PAC97STATE  pThis = RT_FROM_MEMBER(pPciDev, AC97STATE, PciDev);
+    RTIOPORT    Port = (RTIOPORT)GCPhysAddress;
+    int         rc;
 
     Assert(enmType == PCI_ADDRESS_SPACE_IO);
@@ -1355 +1355 @@
 static DECLCALLBACK(int) ichac97SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    AC97LinkState *pThis = PDMINS_2_DATA(pDevIns, AC97LinkState *);
-    AC97LinkState *s = pThis;
-
-    SSMR3PutU32(pSSM, s->glob_cnt);
-    SSMR3PutU32(pSSM, s->glob_sta);
-    SSMR3PutU32(pSSM, s->cas);
-
-    for (unsigned i = 0; i < RT_ELEMENTS(s->bm_regs); i++)
-    {
-        AC97BusMasterRegs *r = &s->bm_regs[i];
-        SSMR3PutU32(pSSM, r->bdbar);
-        SSMR3PutU8( pSSM, r->civ);
-        SSMR3PutU8( pSSM, r->lvi);
-        SSMR3PutU16(pSSM, r->sr);
-        SSMR3PutU16(pSSM, r->picb);
-        SSMR3PutU8( pSSM, r->piv);
-        SSMR3PutU8( pSSM, r->cr);
-        SSMR3PutS32(pSSM, r->bd_valid);
-        SSMR3PutU32(pSSM, r->bd.addr);
-        SSMR3PutU32(pSSM, r->bd.ctl_len);
-    }
-    SSMR3PutMem(pSSM, s->mixer_data, sizeof(s->mixer_data));
+    PAC97STATE pThis = PDMINS_2_DATA(pDevIns, AC97STATE *);
+
+    SSMR3PutU32(pSSM, pThis->glob_cnt);
+    SSMR3PutU32(pSSM, pThis->glob_sta);
+    SSMR3PutU32(pSSM, pThis->cas);
+
+    for (unsigned i = 0; i < RT_ELEMENTS(pThis->bm_regs); i++)
+    {
+        PAC97BMREG pReg = &pThis->bm_regs[i];
+        SSMR3PutU32(pSSM, pReg->bdbar);
+        SSMR3PutU8( pSSM, pReg->civ);
+        SSMR3PutU8( pSSM, pReg->lvi);
+        SSMR3PutU16(pSSM, pReg->sr);
+        SSMR3PutU16(pSSM, pReg->picb);
+        SSMR3PutU8( pSSM, pReg->piv);
+        SSMR3PutU8( pSSM, pReg->cr);
+        SSMR3PutS32(pSSM, pReg->bd_valid);
+        SSMR3PutU32(pSSM, pReg->bd.addr);
+        SSMR3PutU32(pSSM, pReg->bd.ctl_len);
+    }
+    SSMR3PutMem(pSSM, pThis->mixer_data, sizeof(pThis->mixer_data));
 
     uint8_t active[LAST_INDEX];
-    active[PI_INDEX] = AUD_is_active_in( s->voice_pi) ? 1 : 0;
-    active[PO_INDEX] = AUD_is_active_out(s->voice_po) ? 1 : 0;
-    active[MC_INDEX] = AUD_is_active_in( s->voice_mc) ? 1 : 0;
+    active[PI_INDEX] = AUD_is_active_in( pThis->voice_pi) ? 1 : 0;
+    active[PO_INDEX] = AUD_is_active_out(pThis->voice_po) ? 1 : 0;
+    active[MC_INDEX] = AUD_is_active_in( pThis->voice_mc) ? 1 : 0;
     SSMR3PutMem(pSSM, active, sizeof(active));
 
@@ -1393 +1392 @@
 static DECLCALLBACK(int) ichac97LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
-    AC97LinkState *pThis = PDMINS_2_DATA(pDevIns, AC97LinkState *);
-    AC97LinkState *s = pThis;
+    PAC97STATE pThis = PDMINS_2_DATA(pDevIns, AC97STATE *);
 
     AssertMsgReturn (uVersion == AC97_SSM_VERSION, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
     Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
 
-    SSMR3GetU32(pSSM, &s->glob_cnt);
-    SSMR3GetU32(pSSM, &s->glob_sta);
-    SSMR3GetU32(pSSM, &s->cas);
-
-    for (unsigned i = 0; i < RT_ELEMENTS(s->bm_regs); i++)
-    {
-        AC97BusMasterRegs *r = &s->bm_regs[i];
-        SSMR3GetU32(pSSM, &r->bdbar);
-        SSMR3GetU8( pSSM, &r->civ);
-        SSMR3GetU8( pSSM, &r->lvi);
-        SSMR3GetU16(pSSM, &r->sr);
-        SSMR3GetU16(pSSM, &r->picb);
-        SSMR3GetU8( pSSM, &r->piv);
-        SSMR3GetU8( pSSM, &r->cr);
-        SSMR3GetS32(pSSM, &r->bd_valid);
-        SSMR3GetU32(pSSM, &r->bd.addr);
-        SSMR3GetU32(pSSM, &r->bd.ctl_len);
-    }
-
-    SSMR3GetMem(pSSM, s->mixer_data, sizeof(s->mixer_data));
+    SSMR3GetU32(pSSM, &pThis->glob_cnt);
+    SSMR3GetU32(pSSM, &pThis->glob_sta);
+    SSMR3GetU32(pSSM, &pThis->cas);
+
+    for (unsigned i = 0; i < RT_ELEMENTS(pThis->bm_regs); i++)
+    {
+        PAC97BMREG pReg = &pThis->bm_regs[i];
+        SSMR3GetU32(pSSM, &pReg->bdbar);
+        SSMR3GetU8( pSSM, &pReg->civ);
+        SSMR3GetU8( pSSM, &pReg->lvi);
+        SSMR3GetU16(pSSM, &pReg->sr);
+        SSMR3GetU16(pSSM, &pReg->picb);
+        SSMR3GetU8( pSSM, &pReg->piv);
+        SSMR3GetU8( pSSM, &pReg->cr);
+        SSMR3GetS32(pSSM, &pReg->bd_valid);
+        SSMR3GetU32(pSSM, &pReg->bd.addr);
+        SSMR3GetU32(pSSM, &pReg->bd.ctl_len);
+    }
+
+    SSMR3GetMem(pSSM, pThis->mixer_data, sizeof(pThis->mixer_data));
     uint8_t active[LAST_INDEX];
     SSMR3GetMem(pSSM, active, sizeof(active));
 
 #ifdef USE_MIXER
-    record_select(s, mixer_load(s, AC97_Record_Select));
-# define V_(a, b) set_volume(s, a, b, mixer_load(s, a))
+    record_select(pThis, mixer_load(pThis, AC97_Record_Select));
+# define V_(a, b) set_volume(pThis, a, b, mixer_load(pThis, a))
     V_(AC97_Master_Volume_Mute,  AUD_MIXER_VOLUME);
     V_(AC97_PCM_Out_Volume_Mute, AUD_MIXER_PCM);
@@ -1430 +1428 @@
 # undef V_
 #endif /* USE_MIXER */
-    reset_voices(s, active);
-
-    s->bup_flag = 0;
-    s->last_samp = 0;
+    reset_voices(pThis, active);
+
+    pThis->bup_flag = 0;
+    pThis->last_samp = 0;
 
     return VINF_SUCCESS;
@@ -1444 +1442 @@
 static DECLCALLBACK(void *) ichac97QueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
 {
-    AC97LinkState *pThis = RT_FROM_MEMBER(pInterface, AC97LinkState, IBase);
+    PAC97STATE pThis = RT_FROM_MEMBER(pInterface, AC97STATE, IBase);
     Assert(&pThis->IBase == pInterface);
 
@@ -1460 +1458 @@
 static DECLCALLBACK(void)  ac97Reset(PPDMDEVINS pDevIns)
 {
-    AC97LinkState *pThis = PDMINS_2_DATA(pDevIns, AC97LinkState *);
+    PAC97STATE pThis = PDMINS_2_DATA(pDevIns, AC97STATE *);
 
     /*
@@ -1483 +1481 @@
 static DECLCALLBACK(int) ichac97Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
 {
-    AC97LinkState  *pThis = PDMINS_2_DATA(pDevIns, AC97LinkState *);
+    AC97STATE  *pThis = PDMINS_2_DATA(pDevIns, AC97STATE *);
     int             rc;
 
@@ -1628 +1626 @@
     1,
     /* cbInstance */
-    sizeof(AC97LinkState),
+    sizeof(AC97STATE),
     /* pfnConstruct */
     ichac97Construct,