Changeset 31760 in vbox for trunk/src/VBox/Devices/Audio

Timestamp:

Aug 18, 2010 1:06:15 PM (14 years ago)

Author:

vboxsync

Message:

Audio/HDA: Input streams support.

Location:

trunk/src/VBox/Devices/Audio

Files:

• DevCodec.cpp (modified) (5 diffs)
• DevIchIntelHDA.cpp (modified) (14 diffs)

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

@@ -123 +123 @@
 
 static int stac9220ResetNode(struct CODECState *pState, uint8_t nodenum, PCODECNODE pNode);
-static int codecToAudVolume(struct CODECState *pState);
+static int codecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt);
 
 static inline void codecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
@@ -249 +249 @@
         }
         if (CODEC_NID(cmd) == 2)
-            codecToAudVolume(pState);
+            codecToAudVolume(pAmplifier, AUD_MIXER_VOLUME);
+        if (CODEC_NID(cmd) == 0x17) /* Microphone */
+            codecToAudVolume(pAmplifier, AUD_MIXER_PCM);
     }
     return VINF_SUCCESS;
@@ -1010 +1012 @@
             pNode->node.au32F00_param[0xC] = RT_BIT(5)|RT_BIT(2);
             pNode->port.u32F07_param = RT_BIT(5);
-            pNode->port.u32F09_param = 0;
+            pNode->port.u32F09_param = RT_BIT(31);
             if (!pState->fInReset)
-                pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x51, 0x30, 0x81, 0x01);
+                pNode->port.u32F1c_param = (0x2 << 30) /* built-in */ | (0xA << 20) /* mic. */
+                    | (0x1 << 16) | (0x30 << 8) | 0x51;
             break;
         case 0xF:
@@ -1111 +1114 @@
 }
 
-static int codecToAudVolume(struct CODECState *pState)
-{
-    PCODECNODE pNode = &pState->pNodes[2];
-    int mute = AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) & RT_BIT(7);
-    mute |= AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) & RT_BIT(7);
+static int codecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt)
+{
+    uint32_t dir = AMPLIFIER_OUT;
+    switch (mt)
+    {
+        case AUD_MIXER_VOLUME:
+            dir = AMPLIFIER_OUT;
+            break;
+        case AUD_MIXER_PCM:
+        case AUD_MIXER_LINE_IN:
+            dir = AMPLIFIER_IN;
+            break;
+    }
+    int mute = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & RT_BIT(7);
+    mute |= AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & RT_BIT(7);
     mute >>=7;
     mute &= 0x1;
-    uint8_t lVol = AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) & 0x7f;
-    uint8_t rVol = AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) & 0x7f;
-    AUD_set_volume(AUD_MIXER_VOLUME, &mute, &lVol, &rVol);
+    uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & 0x7f;
+    uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & 0x7f;
+    AUD_set_volume(mt, &mute, &lVol, &rVol);
     return VINF_SUCCESS;
 }
@@ -1249 +1262 @@
     if (!pState->voice_po)
         LogRel (("HDAcodec: WARNING: Unable to open PCM OUT!\n"));
-    codecToAudVolume(pState);
+    codecToAudVolume(&pState->pNodes[2].dac.B_params, AUD_MIXER_VOLUME);
+    codecToAudVolume(&pState->pNodes[0x17].adcvol.B_params, AUD_MIXER_PCM);
     return VINF_SUCCESS;
 }

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

@@ -337 +337 @@
 /* Predicates */
 
+typedef struct HDABDLEDESC
+{
+    uint64_t    u64BdleCviAddr;
+    uint32_t    u32BdleMaxCvi;
+    uint32_t    u32BdleCvi;
+    uint32_t    u32BdleCviLen;
+    uint32_t    u32BdleCviPos;
+    bool        fBdleCviIoc; 
+} HDABDLEDESC, *PHDABDLEDESC;
 
 typedef struct INTELHDLinkState
@@ -350 +359 @@
     RTGCPHYS    addrMMReg;
     uint32_t     au32Regs[113];
-    /* Current BD index  */
-    uint32_t    u32Cvi;
-    uint64_t    u64CviAddr;
-    /* Length of current BD entry */
-    uint32_t    u32CviLen;
-    uint32_t    u32CviPos;
-    uint32_t    u32Cbp;
+    HDABDLEDESC  stInBdle;
+    HDABDLEDESC  stOutBdle;
+    HDABDLEDESC  stMicBdle;
     /* Interrupt on completition */
     bool        fCviIoc;
@@ -423 +428 @@
 DECLCALLBACK(int)hdaRegWriteU8(INTELHDLinkState* pState, uint32_t offset, uint32_t index, uint32_t pu32Value);
 static int hdaLookup(INTELHDLinkState* pState, uint32_t u32Offset);
-static void fetch_bd(INTELHDLinkState *pState);
+static void fetch_bd(INTELHDLinkState *pState, PHDABDLEDESC pBdle, uint64_t u64BaseDMA);
 
 /* see 302349 p 6.2*/
@@ -574 +579 @@
 static int hdaProcessInterrupt(INTELHDLinkState* pState)
 {
+#define IS_INTERRUPT_OCCURED_AND_ENABLED(pState, num)                       \
+        (   INTCTL_SX((pState), num)                                        \
+         && (SDSTS(pState, num) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS))) 
     bool fIrq = false;
     if(   INTCTL_CIE(pState)
@@ -582 +590 @@
         fIrq = true;
     }
-    if (   INTCTL_SX(pState, 4)
-        && SDSTS(pState, 4) && HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS))
+    if (   IS_INTERRUPT_OCCURED_AND_ENABLED(pState, 0)
+        || IS_INTERRUPT_OCCURED_AND_ENABLED(pState, 4))
     {
         fIrq = true;
@@ -967 +975 @@
     {
         Log(("hda: DMA(%x) switched on\n", offset));
-        AUD_set_active_in(pState->Codec.voice_pi, 1);
-        AUD_set_active_in(pState->Codec.voice_mc, 1);
+        if (offset == 0x80)
+        {
+            AUD_set_active_in(pState->Codec.voice_pi, 1);
+            //AUD_set_active_in(pState->Codec.voice_mc, 1);
+        }
         if (offset == 0x100)
         {
-            fetch_bd(pState);
-            AUD_set_active_out(pState->Codec.voice_po, 1);
+            uint64_t u64BaseDMA = SDBDPL(pState, 4);
+            u64BaseDMA |= (((uint64_t)SDBDPU(pState, 4)) << 32);
+            if (u64BaseDMA)
+            {
+                //fetch_bd(pState, u64BaseDMA);
+                AUD_set_active_out(pState->Codec.voice_po, 1);
+            }
             //SDSTS(pState, 4) |= (1<<5);
         }
@@ -979 +995 @@
     {
         Log(("hda: DMA(%x) switched off\n", offset));
-        AUD_set_active_in(pState->Codec.voice_pi, 0);
-        AUD_set_active_in(pState->Codec.voice_mc, 0);
+        if (offset == 0x80)
+        {
+            AUD_set_active_in(pState->Codec.voice_pi, 0);
+            //AUD_set_active_in(pState->Codec.voice_mc, 0);
+        }
         if (offset == 0x100)
         {
@@ -1122 +1141 @@
 }
 
-static void dump_bd(INTELHDLinkState *pState)
+static void dump_bd(INTELHDLinkState *pState, PHDABDLEDESC pBdle, uint64_t u64BaseDMA)
 {
     uint64_t addr;
@@ -1131 +1150 @@
     uint32_t i;
     uint32_t sum = 0;
-    for (i = 0; i <= SDLVI(pState, 4); ++i)
-    {
-        PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), SDBDPL(pState, 4) + i*16, bdle, 16);
+    Assert(pBdle && pBdle->u32BdleMaxCvi);
+    for (i = 0; i <= pBdle->u32BdleMaxCvi; ++i)
+    {
+        PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), u64BaseDMA + i*16, bdle, 16);
         addr = *(uint64_t *)bdle;
         len = *(uint32_t *)&bdle[8];
         ioc = *(uint32_t *)&bdle[12];
-        Log(("hda: %s bdle[%d] a:%x, len:%x, ios:%d\n",  (i == pState->u32Cvi? "[C]": "   "), i, addr, len, ioc));
+        Log(("hda: %s bdle[%d] a:%x, len:%x, ios:%d\n",  (i == pBdle->u32BdleCvi? "[C]": "   "), i, addr, len, ioc));
         sum += len;
     }
@@ -1144 +1164 @@
     {
         PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), pState->u64DPBase + i*8, &counter, 4);
-        Log(("hda: %s stream[%d] counter=%x\n", (i) == SDCTL_NUM(pState, 4)? "[C]": "   ", i , counter));
-    }
-}
-static void fetch_bd(INTELHDLinkState *pState)
-{
-    dump_bd(pState);
+        Log(("hda: %s stream[%d] counter=%x\n", i == SDCTL_NUM(pState, 4) || i == SDCTL_NUM(pState, 0)? "[C]": "   ",
+             i , counter));
+    }
+}
+static void fetch_bd(INTELHDLinkState *pState, PHDABDLEDESC pBdle, uint64_t u64BaseDMA)
+{
     uint8_t  bdle[16];
-    PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), SDBDPL(pState, 4) + pState->u32Cvi*16, bdle, 16);
-    pState->u64CviAddr = *(uint64_t *)bdle;
-    pState->u32CviLen = *(uint32_t *)&bdle[8];
-    pState->fCviIoc = (*(uint32_t *)&bdle[12]) & 0x1;
-}
-
+    Assert((u64BaseDMA && pBdle && pBdle->u32BdleMaxCvi));
+    PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), u64BaseDMA + pBdle->u32BdleCvi*16, bdle, 16);
+    pBdle->u64BdleCviAddr = *(uint64_t *)bdle;
+    pBdle->u32BdleCviLen = *(uint32_t *)&bdle[8];
+    pBdle->fBdleCviIoc = (*(uint32_t *)&bdle[12]) & 0x1;
+    dump_bd(pState, pBdle, u64BaseDMA);
+}
+
+static uint32_t read_audio(INTELHDLinkState *pState, int avail, bool *fStop)
+{
+    uint8_t tmpbuf[4096];
+    uint32_t temp;
+    uint32_t u32Rest = 0;
+    uint32_t cbRead = 0;
+    uint32_t to_copy = 0;
+    /* todo: add input line detection */
+    PHDABDLEDESC pBdle = &pState->stInBdle;
+    SWVoiceIn *voice = pState->Codec.voice_pi;
+    u32Rest = pBdle->u32BdleCviLen - pBdle->u32BdleCviPos;
+    temp = audio_MIN(u32Rest, (uint32_t)avail);
+    if (!temp)
+    {
+        *fStop = true;
+        return cbRead;
+    }
+    while (temp)
+    {
+        int copied;
+        to_copy = audio_MIN(temp, 4096U);
+        copied = AUD_read (voice, tmpbuf, to_copy);
+        Log (("hda: read_audio max=%x to_copy=%x copied=%x\n",
+              avail, to_copy, copied));
+        if (!copied)
+        {
+            *fStop = true;
+            break;
+        }
+        PDMDevHlpPhysWrite(ICH6_HDASTATE_2_DEVINS(pState), pBdle->u64BdleCviAddr + pBdle->u32BdleCviPos, tmpbuf, copied);
+        temp    -= copied;
+        cbRead += copied;
+        pBdle->u32BdleCviPos += copied;
+    }
+    return cbRead;
+}
 static uint32_t write_audio(INTELHDLinkState *pState, int avail, bool *fStop)
 {
@@ -1164 +1222 @@
     uint32_t written = 0;
     int to_copy = 0;
-    u32Rest = pState->u32CviLen - pState->u32CviPos;
+    PHDABDLEDESC pBdle = &pState->stOutBdle;
+    u32Rest = pBdle->u32BdleCviLen - pBdle->u32BdleCviPos;
     temp = audio_MIN(u32Rest, (uint32_t)avail);
     if (!temp)
@@ -1175 +1234 @@
         int copied;
         to_copy = audio_MIN(temp, 4096U);
-        PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), pState->u64CviAddr + pState->u32CviPos, tmpbuf, to_copy);
+        PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), pBdle->u64BdleCviAddr + pBdle->u32BdleCviPos, tmpbuf, to_copy);
         copied = AUD_write (pState->Codec.voice_po, tmpbuf, to_copy);
         Log (("hda: write_audio max=%x to_copy=%x copied=%x\n",
@@ -1187 +1246 @@
         temp    -= copied;
         written += copied;
-        pState->u32CviPos += copied;
+        pBdle->u32BdleCviPos += copied;
     }
     return written;
@@ -1201 +1260 @@
 {
     bool fStop = false;
+    uint64_t u64BaseDMA = 0;
+    PHDABDLEDESC pBdle = NULL;
     INTELHDLinkState *pState = (INTELHDLinkState *)pCodecState->pHDAState;
-    switch(src)
+    uint32_t u32Counter;
+    uint32_t nBytes;
+    uint32_t u32Ctl;
+    uint32_t *pu32Sts;
+    uint8_t  u8Strm;
+    uint32_t *pu32Lpib;
+    uint32_t u32Lcbl;
+    switch (src)
     {
         case PO_INDEX:
         {
-            uint32_t written;
-            uint32_t u32Counter;
-            if (   !(SDCTL(pState, 4) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
-                || avail == 0)
-                return;
-            SDCTL(pState, 4) |= ((pState->Codec.pNodes[2].dac.u32F06_param & (0xf << 4)) >> 4) << 20;
-            //fetch_bd(pState);
-            while(   avail
-                  && !fStop)
+            u8Strm = 4;
+            u32Ctl = SDCTL(pState, 4);
+            u64BaseDMA = SDBDPL(pState, 4);
+            u64BaseDMA |= (((uint64_t)SDBDPU(pState, 4)) << 32);
+            pu32Lpib = &SDLPIB(pState, 4);
+            pu32Sts = &SDSTS(pState, 4);
+            u32Lcbl = SDLCBL(pState, 4);
+            pBdle = &pState->stOutBdle;
+            pBdle->u32BdleMaxCvi = SDLVI(pState, 4);
+            break;
+        }
+        case PI_INDEX:
+        {
+            u8Strm = 0;
+            u32Ctl = SDCTL(pState, 0);
+            pu32Lpib = &SDLPIB(pState, 0);
+            pu32Sts = &SDSTS(pState, 0);
+            u32Lcbl = SDLCBL(pState, 0);
+            u64BaseDMA = SDBDPL(pState, 0);
+            u64BaseDMA |= (((uint64_t)SDBDPU(pState, 0)) << 32);
+            pBdle = &pState->stInBdle;
+            pBdle->u32BdleMaxCvi = SDLVI(pState, 0);
+            break;
+        }
+        default:
+            return;
+    }
+    if (   !(u32Ctl & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
+        || !avail
+        || !u64BaseDMA)
+        return;
+    fetch_bd(pState, pBdle, u64BaseDMA);
+    while(   avail
+          && !fStop)
+    {
+        PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1) + u8Strm*8, &u32Counter, 4);
+        switch (src)
+        {
+            case PO_INDEX:
+                nBytes = write_audio(pState, avail, &fStop);
+                break;
+            case PI_INDEX:
+                nBytes = read_audio(pState, avail, &fStop);
+                break;
+            default:
+                AssertMsgFailed(("Unsupported"));
+        }
+        if (   fStop 
+            && pBdle->u32BdleCviLen != pBdle->u32BdleCviPos)
+            break;
+        *pu32Lpib += nBytes;
+        avail -= nBytes;
+        u32Counter += nBytes;
+        PDMDevHlpPhysWrite(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1) + u8Strm*8, &u32Counter, 4);
+        if (   pBdle->u32BdleCviPos == pBdle->u32BdleCviLen
+            || *pu32Lpib == u32Lcbl)
+        {
+            if (   u32Ctl & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE)
+                && (   (   pBdle->u32BdleCviPos == pBdle->u32BdleCviLen
+                        && pBdle->fBdleCviIoc )
+                    || *pu32Lpib == u32Lcbl))
             {
-                PDMDevHlpPhysRead(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1) + 4*8, &u32Counter, 4);
-                written = write_audio(pState, avail, &fStop);
-                if (   fStop 
-                    && pState->u32CviLen != pState->u32CviPos)
-                    break;
-                SDLPIB(pState, 4) += written; /* bytes ? */
-                avail -= written;
-                u32Counter += written;
-                PDMDevHlpPhysWrite(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1) + 4*8, &u32Counter, 4);
-                if (   pState->u32CviPos == pState->u32CviLen
-                    || SDLPIB(pState, 4) == SDLCBL(pState, 4))
+                *pu32Sts |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
+                hdaProcessInterrupt(pState);
+                if (*pu32Lpib == u32Lcbl)
                 {
-                    if (   SDCTL(pState, 4) & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE)
-                        && (   (   pState->u32CviPos == pState->u32CviLen
-                                && pState->fCviIoc )
-                            || SDLPIB(pState, 4) == SDLCBL(pState, 4)))
-                    {
-                        SDSTS(pState,4) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
-                        hdaProcessInterrupt(pState);
-                        if (SDLPIB(pState, 4) == SDLCBL(pState, 4))
-                        {
-                            SDLPIB(pState, 4) = 0;
-                            u32Counter = 0;
-                            PDMDevHlpPhysWrite(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1)  + 4*8, &u32Counter, 4);
-                        }
-                    }
-                    if (pState->u32CviPos == pState->u32CviLen)
-                    {
-                        pState->u32CviPos = 0;
-                        pState->u32Cvi++;
-                        if (pState->u32Cvi == SDLVI(pState, 4) + 1)
-                            pState->u32Cvi = 0;
-                    }
-                    fStop = false;
-                    fetch_bd(pState);
+                    *pu32Lpib = 0;
+                    u32Counter = 0;
+                    PDMDevHlpPhysWrite(ICH6_HDASTATE_2_DEVINS(pState), (pState->u64DPBase & ~0x1)  + u8Strm*8, &u32Counter, 4);
                 }
             }
+            if (pBdle->u32BdleCviPos == pBdle->u32BdleCviLen)
+            {
+                pBdle->u32BdleCviPos = 0;
+                pBdle->u32BdleCvi++;
+                if (pBdle->u32BdleCvi == pBdle->u32BdleMaxCvi + 1)
+                    pBdle->u32BdleCvi = 0;
+            }
+            fStop = false;
+            fetch_bd(pState, pBdle, u64BaseDMA);
         }
-        break;
-        AssertMsgFailed(("Unexpected index: %x\n", src));
-        default:
-            break;
     }
 }