// ****************************************************************************
//
//		OsSupportBeOS.cpp
//
//		Implementation file for BeOS support services to the CEchoGals
//		generic driver 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
//
// ****************************************************************************

#include "OsSupportBeOS.h"

#include "EchoGalsXface.h"

#include <KernelExport.h>
#include "util.h"

//
//	Version information.
//	In NT, we want to get this from a resource
//
BYTE OsGetVersion()
{
	// Use EngFindResource, for now hard code
	return( 1 );	
}	// BYTE OsGetVersion()

BYTE OsGetRevision()
{
	// Use EngFindResource, for now hard code
	return( 0 );	
}	// BYTE OsGetRevision()

BYTE OsGetRelease()
{
	// Use EngFindResource, for now hard code
	return( 0 );	
}	// BYTE OsGetRelease()

//
//	Global Memory Management Functions
//
DWORD gAllocNonPagedCount = 0;

LIST_HEAD(mems, _echo_mem) mems;


static echo_mem *
echo_mem_new(size_t size)
{
	echo_mem *mem = NULL;

	if ((mem = (echo_mem*)malloc(sizeof(*mem))) == NULL)
		return (NULL);

	mem->area = alloc_mem(&mem->phy_base, &mem->log_base, size, "echo buffer", true);
	mem->size = size;
	if (mem->area < B_OK) {
		free(mem);
		return NULL;
	}
	return mem;
}

static void
echo_mem_delete(echo_mem *mem)
{
	if(mem->area > B_OK)
		delete_area(mem->area);
	free(mem);
}

echo_mem *
echo_mem_alloc(size_t size)
{
	echo_mem *mem = NULL;

	mem = echo_mem_new(size);
	if (mem == NULL)
		return (NULL);

	LIST_INSERT_HEAD(&mems, mem, next);

	return mem;
}

void
echo_mem_free(void *ptr)
{
	echo_mem *mem = NULL;

	LIST_FOREACH(mem, &mems, next) {
		if (mem->log_base != ptr)
			continue;
		LIST_REMOVE(mem, next);

		echo_mem_delete(mem);
		break;
	}
}

void OsAllocateInit()
{
	gAllocNonPagedCount = 0;

	/* Init mems list */
	LIST_INIT(&mems);
}

// ***********************************************************************
//
//  Allocate locked, non-pageable block of memory.  Does not have to be
//	physically contiguous.  Primarily used to implement the overloaded
//	new operator.
//
// ***********************************************************************

ECHOSTATUS OsAllocateNonPaged
(
    DWORD	dwByteCt,				// Block size in bytes
    PPVOID	ppMemAddr				// Where to return memory ptr
)
{
	
	
	echo_mem * mem = echo_mem_alloc( dwByteCt );
	if(mem)
		*ppMemAddr = mem->log_base;
	
	if ( NULL == *ppMemAddr )
	{
		ECHO_DEBUGPRINTF( ("OsAllocateNonPaged : Failed on %ld bytes\n",
								 dwByteCt) );
		ECHO_DEBUGBREAK();				 
		return ECHOSTATUS_NO_MEM;
	}
	
	OsZeroMemory( *ppMemAddr, dwByteCt );
	
	gAllocNonPagedCount++;
	ECHO_DEBUGPRINTF(("gAllocNonPagedCount %ld\n",gAllocNonPagedCount));
	
	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS OsAllocateNonPaged


// ***********************************************************************
//
// Unlock and free, non-pageable block of memory.
//
// ***********************************************************************
ECHOSTATUS OsFreeNonPaged
(
    PVOID	pMemAddr
)
{
	echo_mem_free( pMemAddr );

	gAllocNonPagedCount--;
	ECHO_DEBUGPRINTF(("gAllocNonPagedCount %ld\n",gAllocNonPagedCount));

	return ECHOSTATUS_OK;

}	// ECHOSTATUS OsFreeNonPaged



// ***********************************************************************
//
// This class is optional and uniquely defined for each OS.  It provides
//	information that other components may require.
// For example, in Windows NT it contains a device object used by various
//	memory management methods.
// Since static variables are used in place of globals, an instance must
//	be constructed and initialized by the OS Interface object prior to
//	constructing the CEchoGals derived object.  The CEchoGals and
//	CDspCommObject classes must have access to it during their respective 
// construction times.
//
// ***********************************************************************

COsSupport::COsSupport
(
	WORD				wDeviceId,		// PCI bus device ID
	WORD				wCardRev			// Card revision number
)
{
   ECHO_DEBUGPRINTF(("COsSupport::COsSupport born, device id = 0x%x.\n", wDeviceId));

	m_wDeviceId = wDeviceId;
	m_wCardRev = wCardRev;
}

COsSupport::~COsSupport()
{
	ECHO_DEBUGPRINTF(("COsSupport is all gone - m_dwPageBlockCount %ld\n",m_dwPageBlockCount));
}

//
//	Timer Methods
//

ECHOSTATUS COsSupport::OsGetSystemTime
(
	PULONGLONG	pullTime					// Where to return system time
)
{
	*pullTime = ULONGLONG(system_time());

	return ECHOSTATUS_OK;

}	// ECHOSTATUS COsSupport::OsGetSystemTime


ECHOSTATUS COsSupport::OsSnooze
(
	DWORD	dwTime						// Duration in micro seconds
)
{
	status_t status;
	status = snooze(bigtime_t(dwTime));
	switch (status) {
		case B_OK:
			return ECHOSTATUS_OK;
			break;
		case B_INTERRUPTED:
			return ECHOSTATUS_OPERATION_CANCELED; // maybe not appropriate, but anyway
			break;
		default:
			return ECHOSTATUS_NOT_SUPPORTED; // no generic error?
			break;
	}
}


//
//	Memory Management Methods
//

//---------------------------------------------------------------------------
//
//	Allocate a physical page block that can be used for DSP bus mastering.
//
//---------------------------------------------------------------------------

ECHOSTATUS COsSupport::AllocPhysPageBlock
(
	DWORD			dwBytes,
	PPAGE_BLOCK	&pPageBlock
)
{
	DWORD	dwRoundedBytes;
	
	//
	// Allocate
	//
	dwRoundedBytes = (dwBytes + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
	ECHO_DEBUGPRINTF(("COsSupport::AllocPhysPageBlock - dwBytes %ld  dwRoundedBytes %ld\n",
							dwBytes,dwRoundedBytes));
	
	pPageBlock = echo_mem_alloc ( dwRoundedBytes );

	if (NULL == pPageBlock)
	{
		ECHO_DEBUGPRINTF(("AllocPhysPageBlock failed for %ld bytes\n",dwBytes));

		pPageBlock = NULL;
		return ECHOSTATUS_NO_MEM;
	}
	
	ECHO_DEBUGPRINTF(("\tIOBufferMemoryDescriptor is OK\n"));

	OsZeroMemory( pPageBlock->log_base, dwRoundedBytes );
	
#ifdef _DEBUG
	m_dwPageBlockCount++;
	ECHO_DEBUGPRINTF(("\tm_dwPageBlockCount %ld\n",m_dwPageBlockCount));
#endif
	
	return ECHOSTATUS_OK;

}	// AllocPageBlock


//---------------------------------------------------------------------------
//
//	Free a physical page block
//
//---------------------------------------------------------------------------

ECHOSTATUS COsSupport::FreePhysPageBlock
(
	DWORD			dwBytes,
	PPAGE_BLOCK	pPageBlock
)
{
	echo_mem_free(pPageBlock->log_base);
	
#ifdef _DEBUG
	m_dwPageBlockCount--;
	ECHO_DEBUGPRINTF(("\tm_dwPageBlockCount %ld\n",m_dwPageBlockCount));
#endif
	
	return ECHOSTATUS_OK;
	
}	// FreePageBlock


//---------------------------------------------------------------------------
//
//	Get the virtual address for the buffer corresponding to the MDL
//
//---------------------------------------------------------------------------

PVOID COsSupport::GetPageBlockVirtAddress
(
	PPAGE_BLOCK	pPageBlock
)
{

	return pPageBlock->log_base;
		
}	// GetPageBlockVirtAddress


//---------------------------------------------------------------------------
//
//	Get the physical address for part of the buffer corresponding to the MDL
//
//---------------------------------------------------------------------------

ECHOSTATUS COsSupport::GetPageBlockPhysSegment
(
	PPAGE_BLOCK	pPageBlock,			// pass in a previously allocated block
	DWORD			dwOffset,			// pass in the offset into the block
	PHYS_ADDR	&PhysAddr,			// returns the physical address
	DWORD			&dwSegmentSize		// and the length of the segment
)
{

	PhysAddr = ((PHYS_ADDR)pPageBlock->phy_base + dwOffset);
	
	return ECHOSTATUS_OK;

} // GetPageBlockPhysSegment


//
// Add additional methods here
//

//
//	Display an error message w/title
//
void COsSupport::EchoErrorMsg(const char* pszMsg, const char* pszTitle)
{
}

PVOID COsSupport::operator new(size_t size)
{
	PVOID 		pMemory;

	pMemory = malloc(size);
	
	if ( NULL == pMemory )
	{
		ECHO_DEBUGPRINTF(("COsSupport::operator new - memory allocation failed\n"));

		pMemory = NULL;
	}
	else
	{
		memset( pMemory, 0, size );
	}
		
	return pMemory;
}

VOID COsSupport::operator delete(PVOID memory)
{
	free(memory);
}