// **************************************************************************** // // CDaffyDuck.CPP // // Implementation file for the CDaffyDuck class. // Set editor tabs to 3 for your viewing pleasure. // // This file is part of Echo Digital Audio's generic driver library. // Copyright Echo Digital Audio Corporation (c) 1998 - 2005 // All rights reserved // www.echoaudio.com // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // //--------------------------------------------------------------------------- // // The head pointer tracks the next free slot in the circular buffers // The tail pointer tracks the oldest mapping. // // Fixme add integrity checks for all functions // //**************************************************************************** #include "CEchoGals.h" /**************************************************************************** Construction/destruction ****************************************************************************/ //=========================================================================== // // Overload new & delete so memory for this object is allocated // from non-paged memory. // //=========================================================================== PVOID CDaffyDuck::operator new( size_t Size ) { PVOID pMemory; ECHOSTATUS Status; Status = OsAllocateNonPaged(Size,&pMemory); if ( (ECHOSTATUS_OK != Status) || (NULL == pMemory )) { ECHO_DEBUGPRINTF(("CDaffyDuck::operator new - memory allocation failed\n")); pMemory = NULL; } else { memset( pMemory, 0, Size ); } return pMemory; } // PVOID CDaffyDuck::operator new( size_t Size ) VOID CDaffyDuck::operator delete( PVOID pVoid ) { if ( ECHOSTATUS_OK != OsFreeNonPaged( pVoid ) ) { ECHO_DEBUGPRINTF(("CDaffyDuck::operator delete memory free failed\n")); } } // VOID CDaffyDuck::operator delete( PVOID pVoid ) //=========================================================================== // // Constructor // //=========================================================================== CDaffyDuck::CDaffyDuck ( PCOsSupport pOsSupport ) { // // Stash stuff // m_pOsSupport = pOsSupport; } // CDaffyDuck::CDaffyDuck() //=========================================================================== // // Destructor // //=========================================================================== CDaffyDuck::~CDaffyDuck() { if (NULL != m_pDuckPage) m_pOsSupport->FreePhysPageBlock( PAGE_SIZE, m_pDuckPage); } // CDaffyDuck::~CDaffyDuck() /**************************************************************************** Setup and initialization ****************************************************************************/ //=========================================================================== // // Reset - resets the mapping and duck entry circular buffers // //=========================================================================== void CDaffyDuck::Reset() { // // Zero stuff // OsZeroMemory(m_Mappings,sizeof(m_Mappings)); m_dwHead = 0; m_dwTail = 0; m_dwCount = 0; m_ullLastEndPos = 0; // // Set all duck entries to "end of list" except for the last one // DWORD i; for (i = 0; i < MAX_ENTRIES; i++) { m_DuckEntries[i].PhysAddr = 0; m_DuckEntries[i].dwSize = 0xffffffff; } // // Put the physical address of the duck at the end of // the m_DuckEntries array so the DSP will wrap around // to the start of the duck. // m_DuckEntries[MAX_ENTRIES].PhysAddr = SWAP( m_dwDuckEntriesPhys ); m_DuckEntries[MAX_ENTRIES].dwSize = 0; } // Reset //=========================================================================== // // ResetStartPos - Takes the current list and re-calculates the // DMA end position for each mapping, starting at DMA position zero. // //=========================================================================== void CDaffyDuck::ResetStartPos() { DWORD dwRemaining,dwIndex; m_ullLastEndPos = 0L; // // Re-calculate the end positions // dwRemaining = m_dwCount; dwIndex = m_dwTail; while (0 != dwRemaining) { if ( ( 0 != m_DuckEntries[ dwIndex ].dwSize) && ( 0 != m_DuckEntries[ dwIndex ].PhysAddr ) ) { m_Mappings[dwIndex].ullEndPos = m_ullLastEndPos + SWAP( m_DuckEntries[ dwIndex ].dwSize ); m_ullLastEndPos = m_Mappings[ dwIndex ].ullEndPos; } else { m_Mappings[dwIndex].ullEndPos = m_ullLastEndPos; } dwIndex++; dwIndex &= ENTRY_INDEX_MASK; dwRemaining--; } } // ResetStartPos /**************************************************************************** Mapping management ****************************************************************************/ //=========================================================================== // // AddMapping // // Take a mapping and add it to the circular buffer. // // Note that the m_DuckEntries array is read by the DSP; entries must // therefore be stored in little-endian format. // // The buffer pointed to by dwPhysAddr and dwBytes must be // physically contiguous. // //=========================================================================== ECHOSTATUS CDaffyDuck::AddMapping ( DWORD dwPhysAddr, DWORD dwBytes, NUINT Tag, DWORD dwInterrupt, DWORD &dwNumFreeEntries ) { #ifdef INTEGRITY_CHECK CheckIntegrity(); #endif // // There must always be at least one free entry for the "end of list" // entry. dwInterrupt may be non-zero, so make sure that there's enough // room for two more entries // if ((MAX_ENTRIES - m_dwCount) < 3) { ECHO_DEBUGPRINTF(("AddMapping - duck is full\n")); return ECHOSTATUS_DUCK_FULL; } // // At least two slots are available in the circular // buffer, so it's OK to add either a regular mapping or // a mapping with a double zero // m_DuckEntries[m_dwHead].PhysAddr = SWAP( dwPhysAddr ); m_DuckEntries[m_dwHead].dwSize = SWAP( dwBytes ); m_Mappings[m_dwHead].Tag = Tag; m_Mappings[m_dwHead].ullEndPos = m_ullLastEndPos + dwBytes; m_ullLastEndPos = m_Mappings[m_dwHead].ullEndPos; // // If the caller wants an interrupt after this mapping, then // dwInterrupt will be non-zero // if (dwInterrupt) { DWORD dwNext; // // Put in the double zero so the DSP will // generate an interrupt // dwNext = m_dwHead + 1; dwNext &= ENTRY_INDEX_MASK; m_DuckEntries[dwNext].PhysAddr = 0; // no need to swap zero! m_DuckEntries[dwNext].dwSize = 0; m_Mappings[dwNext].ullEndPos = m_ullLastEndPos; m_dwHead += 2; m_dwCount += 2; } else { m_dwHead++; m_dwCount++; } // // Wrap the head index // m_dwHead &= ENTRY_INDEX_MASK; // // Return value to the caller // dwNumFreeEntries = MAX_ENTRIES - m_dwCount; //#ifdef _DEBUG #if 0 DWORD hi,lo; hi = (DWORD) (m_ullLastEndPos >> 32); lo = (DWORD) (m_ullLastEndPos & 0xffffffffL); ECHO_DEBUGPRINTF(("Added tag %ld, end pos 0x%08lx%08lx (int %ld)\n",Tag,hi,lo,dwInterrupt)); #ifdef INTEGRITY_CHECK CheckIntegrity(); #endif ECHO_DEBUGPRINTF(("Daffy duck count is %ld\n",m_dwCount)); #endif return ECHOSTATUS_OK; } // AddMapping //=========================================================================== // // AddDoubleZero // // Adds a double zero to the circular buffer to cause the DSP to generate an // IRQ. // //=========================================================================== ECHOSTATUS CDaffyDuck::AddDoubleZero() { // // There must always be at least one free entry for the "end of list" // entry. // if ((MAX_ENTRIES - m_dwCount) < 2) { ECHO_DEBUGPRINTF(("AddDoubleZero - duck is full\n")); return ECHOSTATUS_DUCK_FULL; } //ECHO_DEBUGPRINTF(("CDaffyDuck::AddDoubleZero m_dwCount %ld\n",m_dwCount)); // // Add the double zero // m_DuckEntries[m_dwHead].PhysAddr = 0; m_DuckEntries[m_dwHead].dwSize = 0; m_Mappings[m_dwHead].ullEndPos = m_ullLastEndPos; // // Housekeeping // m_dwHead++; m_dwHead &= ENTRY_INDEX_MASK; m_dwCount++; return ECHOSTATUS_OK; } // AddDoubleZero //=========================================================================== // // Wrap // // Put a "next PLE" pointer at the end of the duck to make the DSP // wrap around to the start; this creates a circular buffer. // //=========================================================================== void CDaffyDuck::Wrap() { ECHO_ASSERT(m_dwCount != MAX_ENTRIES); // // Put in the address of the start of the duck entries // and a count of zero; a count of zero tells the DSP // "Go look again for a duck entry at this address" // m_DuckEntries[m_dwHead].PhysAddr = SWAP( m_dwDuckEntriesPhys ); m_DuckEntries[m_dwHead].dwSize = 0; m_dwHead++; m_dwHead &= ENTRY_INDEX_MASK; m_dwCount++; m_fWrapped = TRUE; } // Wrap //=========================================================================== // // ReleaseUsedMappings // // Find all the mapping that've been consumed and return a list of tags // // Return value is the number of tags written to the array // //=========================================================================== DWORD CDaffyDuck::ReleaseUsedMappings ( ULONGLONG ullDmaPos, NUINT *Tags, // an array of tags DWORD dwMaxTags // the max number of tags in the array ) { DWORD dwTempAddr,dwTempSize; NUINT Tag; DWORD dwTagsFree; dwTagsFree = dwMaxTags; while ( (0 != m_dwCount) && (0 != dwTagsFree) ) { // // Get the data from the tail // Tag = m_Mappings[m_dwTail].Tag; dwTempAddr = SWAP( m_DuckEntries[m_dwTail].PhysAddr ); dwTempSize = SWAP( m_DuckEntries[m_dwTail].dwSize ); // // Is this an audio data mapping? // if ( (0 != dwTempAddr) && (0 != dwTempSize) ) { // // Is this audio data mapping done? // if ( ullDmaPos < m_Mappings[m_dwTail].ullEndPos ) break; // // This one's done // *Tags = Tag; Tags++; dwTagsFree--; EjectTail(); } else { // // Is this non-audio data mapping done? // if ( ullDmaPos <= m_Mappings[m_dwTail].ullEndPos ) break; // // Pop it // EjectTail(); } } // // Return the number written // return dwMaxTags - dwTagsFree; } // ReleaseUsedMappings //=========================================================================== // // RevokeMappings // // Returns the number actually revoked // //=========================================================================== DWORD CDaffyDuck::RevokeMappings(NUINT FirstTag,NUINT LastTag) { NUINT Offset; DWORD dwNumRevoked; dwNumRevoked = 0; //---------------------------------------------------------------------- // // The tags may be 32 bit counters, so it is possible that they will // wrap around (that is, dwLastTag may be less than dwFirstTag). If the // tags have wrapped, use an offset so the compares work correctly. // //---------------------------------------------------------------------- Offset = 0; if (LastTag < FirstTag) { Offset = LastTag; LastTag -= Offset; FirstTag -= Offset; } //---------------------------------------------------------------------- // // Go through the list and revoke stuff // //---------------------------------------------------------------------- DWORD dwCount; DWORD dwCurrentIndex; DWORD dwNextIndex; NUINT AdjustedTag; dwCurrentIndex = m_dwTail; dwCount = m_dwCount; while (dwCount != 0) { // // Get info for this mapping // AdjustedTag = m_Mappings[dwCurrentIndex].Tag - Offset; // // Only check this mapping if it contains audio data // if ( (0 != m_DuckEntries[dwCurrentIndex].PhysAddr) && (0 != m_DuckEntries[dwCurrentIndex].dwSize) ) { // // See if the current mapping needs to be revoked // if ((FirstTag <= AdjustedTag) && (AdjustedTag <= LastTag)) { // // Revoke this tag // dwNumRevoked++; // // Change this duck into a duck entry pointer; the DSP // will see that the size is zero and re-fetch the duck entry // from the address specified in PhysAddr. // dwNextIndex = dwCurrentIndex + 1; dwNextIndex &= ENTRY_INDEX_MASK; m_DuckEntries[dwCurrentIndex].PhysAddr = m_dwDuckEntriesPhys + (dwNextIndex * sizeof(DUCKENTRY) ); m_DuckEntries[dwCurrentIndex].dwSize = 0; } } dwCurrentIndex++; dwCurrentIndex &= ENTRY_INDEX_MASK; dwCount--; } //---------------------------------------------------------------------- // // If any mappings were revoked, do various housekeeping tasks // //---------------------------------------------------------------------- if (0 != dwNumRevoked) { CleanUpTail(); ResetStartPos(); } return dwNumRevoked; } // RevokeMappings //=========================================================================== // // CleanUpTail // // Removes any non-audio mappings from the tail of the list; stops // removing if it finds an audio mapping // //=========================================================================== void CDaffyDuck::CleanUpTail() { while (0 != m_dwCount) { // // Quit the loop at the first audio data entry // if ( (0 != m_DuckEntries[ m_dwTail ].PhysAddr) && (0 != m_DuckEntries[ m_dwTail ].dwSize) ) break; // // Pop goes the weasel // EjectTail(); } } // CleanUpTail //=========================================================================== // // EjectTail // // Removes a single mapping from the tail of the list // //=========================================================================== void CDaffyDuck::EjectTail() { #ifdef _DEBUG if (0 == m_dwCount) { ECHO_DEBUGPRINTF(("EjectTail called with zero count!\n")); ECHO_DEBUGBREAK(); return; } #endif // // Mark this entry with the "end of list" values // m_DuckEntries[ m_dwTail ].PhysAddr = 0; m_DuckEntries[ m_dwTail ].dwSize = 0xffffffff; // // Move the tail forward and decrement the count // m_dwTail++; m_dwTail &= ENTRY_INDEX_MASK; m_dwCount--; } // EjectTail //=========================================================================== // // Adjusts the duck so that DMA will start from a given position; useful // when resuming from pause // //=========================================================================== void CDaffyDuck::AdjustStartPos(ULONGLONG ullPos) { DWORD dwCount,dwIndex; ULONGLONG ullMapStartPos; DWORD dwPhysAddr; DWORD dwSize; dwCount = m_dwCount; dwIndex = m_dwTail; while (0 != dwCount) { // // Check DMA pos // if (ullPos >= m_Mappings[dwIndex].ullEndPos) break; dwSize = SWAP(m_DuckEntries[dwIndex].dwSize); ullMapStartPos = m_Mappings[dwIndex].ullEndPos - dwSize; if (ullPos >= ullMapStartPos) { dwPhysAddr = SWAP(m_DuckEntries[dwIndex].PhysAddr); if ( (0 != dwPhysAddr) && (0 != dwSize) ) { DWORD dwDelta; dwDelta = (DWORD) (m_Mappings[dwIndex].ullEndPos - ullPos); dwPhysAddr += dwDelta; dwSize -= dwDelta; m_DuckEntries[dwIndex].PhysAddr = SWAP(dwPhysAddr); m_DuckEntries[dwIndex].dwSize = SWAP(dwSize); break; } } dwCount--; dwIndex++; dwIndex &= ENTRY_INDEX_MASK; } } //=========================================================================== // // GetPhysStartAddr // // This returns the physical address of the start of the scatter-gather // list; used to tell the DSP where to start looking for duck entries. // //=========================================================================== DWORD CDaffyDuck::GetPhysStartAddr() { return m_dwDuckEntriesPhys + (m_dwTail * sizeof(DUCKENTRY)); } //=========================================================================== // // CheckIntegrity // // Debug code - makes sure that the buffer count, head, and tail all agree // //=========================================================================== #ifdef INTEGRITY_CHECK void CDaffyDuck::CheckIntegrity() { DWORD dwDiff,dwCount,dwTemp,dwSum; dwDiff = m_dwHead - m_dwTail; if (dwDiff > 0x80000000) dwDiff += MAX_ENTRIES; if ((0 == dwDiff) && (MAX_ENTRIES == m_dwCount)) return; if (dwDiff != m_dwCount) { ECHO_DEBUGPRINTF(("CDaffyDuck integrity check fail! m_dwHead %ld m_dwTail %ld " "m_dwCount %ld m_Mappings[m_dwHead].dwNumEntries %ld\n", m_dwHead,m_dwTail,m_dwCount,m_Mappings[m_dwHead].dwNumEntries)); ECHO_DEBUGBREAK(); } dwTemp = m_dwTail; dwCount = m_dwCount; dwSum = 0; while (dwCount) { dwSum += m_Mappings[dwTemp].dwNumEntries; dwCount--; dwTemp++; dwTemp &= ENTRY_INDEX_MASK; } if (dwSum != m_dwCount) { ECHO_DEBUGPRINTF(("CDaffyDuck integrity check fail! dwSum %ld m_dwCount %ld\n", dwSum,m_dwCount)); ECHO_DEBUGBREAK(); } } // CheckIntegrity #endif // INTEGRITY_CHECK VOID CDaffyDuck::DbgDump() { ECHO_DEBUGPRINTF(("duck list starts at virt %p, phys %08x\n",m_DuckEntries,m_dwDuckEntriesPhys)); ECHO_DEBUGPRINTF(("count %d head %d tail %d\n",m_dwCount,m_dwHead,m_dwTail)); ECHO_DEBUGPRINTF(("Head phys %08x tail phys %08x\n", (m_dwHead * sizeof(DUCKENTRY)) + m_dwDuckEntriesPhys, (m_dwTail * sizeof(DUCKENTRY)) + m_dwDuckEntriesPhys)); DWORD idx,count; idx = m_dwTail; count = m_dwCount; while (count != 0) { ECHO_DEBUGPRINTF(("\t%08x : %08x %08x\n",(idx * sizeof(DUCKENTRY)) + m_dwDuckEntriesPhys, m_DuckEntries[idx].dwSize,m_DuckEntries[idx].PhysAddr)); count--; idx ++; idx &= ENTRY_INDEX_MASK; } } //=========================================================================== // // This function is used to create a CDaffyDuck object to // manage a scatter-gather list for a newly opened pipe. Call // this instead of using "new CDaffyDuck" directly. // //=========================================================================== CDaffyDuck * CDaffyDuck::MakeDaffyDuck(COsSupport *pOsSupport) { ECHOSTATUS Status = ECHOSTATUS_OK; CDaffyDuck *pDuck; pDuck = new CDaffyDuck( pOsSupport ); if (NULL == pDuck) { ECHO_DEBUGPRINTF(("CDaffyDuck::CDaffyDuck - duck entry malloc failed\n")); return NULL; } // // Allocate the page for the duck entries // DWORD dwSegmentSize; PHYS_ADDR PhysAddr; PPAGE_BLOCK pPageBlock; Status = pOsSupport->AllocPhysPageBlock( PAGE_SIZE, pPageBlock); if (ECHOSTATUS_OK != Status) { ECHO_DEBUGPRINTF(("CDaffyDuck::CDaffyDuck - duck entry page block malloc failed\n")); delete pDuck; return NULL; } pDuck->m_pDuckPage = pPageBlock; pDuck->m_DuckEntries = (DUCKENTRY *) pOsSupport->GetPageBlockVirtAddress( pPageBlock ); pOsSupport->GetPageBlockPhysSegment(pPageBlock, 0, PhysAddr, dwSegmentSize); pDuck->m_dwDuckEntriesPhys = PhysAddr; // // Finish initializing // pDuck->Reset(); return pDuck; } // MakeDaffyDuck // *** CDaffyDuck.cpp ***
