///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Winnov L.P., 1997.  All rights reserved
// api.c: asrc exported API  
//
// Modified : C++ -> C
///////////////////////////////////////////////////////////////////////////////

#include "common.h"
#include "wnv1632.h"
#include "wnvasrc.h"
#include "asrc.h"
#include "debug.h"

#ifdef WINKERNEL
#else
#include <malloc.h>
#endif

///////////////////////////////////////////////////////////////////////////////

#ifdef WINKERNEL
PVOID MyAlloc (UINT nSize)
{
    return ExAllocatePool (NonPagedPool, nSize);
}

void MyFree (PVOID pMem)
{
    ExFreePool (pMem);
}

#else
#ifdef WIN32
PVOID MyAlloc (UINT nSize)
{
    return malloc (nSize);
}

void MyFree (PVOID pMem)
{
    free (pMem);
}
#else
BYTE gbAllocBuf [sizeof(ASRC)+sizeof(SHARED)+1024];
UINT gnAllocIndex = 0;

PVOID MyAlloc (UINT nSize)
{
    UINT n;
    
    n = gnAllocIndex;
    gnAllocIndex += nSize;
    if (nSize > sizeof (gbAllocBuf))
    	return NULL;
    return &gbAllocBuf [n];
}

void MyFree (PVOID pMem)
{
}
#endif
#endif

///////////////////////////////////////////////////////////////////////////////

WNVEXPORT(AsrcGet (DWORD dwAPI, DWORD dwItem))
{
    PASRC pAPI;
	DWORD dwResult;

    pAPI = (PASRC)(NEARPTR)dwAPI;
    if (!pAPI) 
	{
		TraceString ("AsrcGet: Bad dwAPI.\n");
		return 0;
	}

    dwResult = IAsrcGet (pAPI, dwItem);
	TraceString ("AsrcGet: dwItem=");
	TraceLong (dwItem);
	TraceString (", return=");
	TraceLong (dwResult);
	TraceString ("\n");

	return dwResult;
}

WNVEXPORT(AsrcSet (DWORD dwAPI, DWORD dwItem, DWORD dwVal))
{
    PASRC pAPI;
    
    pAPI = (PASRC)(NEARPTR)dwAPI;
    if (!pAPI)
	{
		TraceString ("AsrcSet: Bad dwAPI.\n");
		return 0;
	}

	TraceString ("AsrcSet: dwItem=");
	TraceLong (dwItem);
	TraceString (", dwVal=");
	TraceLong (dwVal);
	TraceString ("\n");

    return IAsrcSet (pAPI, dwItem, dwVal);
}

WNVEXPORT(AsrcRead (DWORD dwAPI, LPVOID lpBuf, DWORD dwSize))
{
    PASRC pAPI;

    pAPI = (PASRC)(NEARPTR)dwAPI;
    if (!pAPI)
	{
		TraceString ("AsrcRead: Bad dwAPI.\n");
		return 0;
	}
    return IAsrcRead (pAPI, lpBuf, dwSize);
}

WNVEXPORT(AsrcWrite (DWORD dwAPI, LPVOID lpBuf, DWORD dwSize))
{
    PASRC pAPI;

    pAPI = (PASRC)(NEARPTR)dwAPI;
    if (!pAPI)
	{
		TraceString ("AsrcWrite: Bad dwAPI.\n");
		return 0;
	}
    return IAsrcWrite (pAPI, lpBuf, dwSize);
}

WNVEXPORT(AsrcMessage (DWORD dwAPI, DWORD dwMessage))
{
    PASRC pAPI;
	DWORD dwResult;

    pAPI = (PASRC)(NEARPTR)dwAPI;
    if (!pAPI)
	{
		TraceString ("AsrcMessage: Bad dwAPI.\n");
		return 0;
	}
    dwResult = IAsrcMessage (pAPI, dwMessage);

	TraceString ("AsrcMessage: dwMessage=");
	TraceLong (dwMessage);
	TraceString (", return=");
	TraceLong (dwResult);
	TraceString ("\n");

	return dwResult;
}

WNVEXPORT(AsrcInstanceSize (void))
{
	return sizeof (ASRC);
}

WNVEXPORT(AsrcSharedSize (void))
{
	return sizeof (SHARED);
}

WNVEXPORT(AsrcConstructor (UINT nBoard))
{
    PASRC pAPI;

	TraceString ("AsrcConstructor: nBoard=\n");
	TraceLong (nBoard);

    pAPI = MyAlloc (sizeof (ASRC));
    if (!pAPI) 
	{
		TraceString ("AsrcConstructor: MyAlloc failed.\n");
		return 0;
	}

    pAPI->m_pShared = MyAlloc (sizeof (SHARED));
    if (!pAPI->m_pShared)
	{
		TraceString ("AsrcConstructor: MyAlloc failed.\n");
		return 0;
	}
#ifdef WINKERNEL
    pAPI->m_pIrp = (PIRP)nBoard;
#else
    pAPI->m_pIrp = NULL;
#endif
    pAPI->m_nBoard = nBoard;
    IAsrcConstructor (pAPI);

	osdepNew (pAPI);

	TraceString ("AsrcConstructor: return=");
	TraceLong ((DWORD)pAPI);
	TraceString ("\n");

    return (DWORD)(NEARPTR)pAPI;
}

WNVEXPORT(AsrcDestructor (DWORD dwAPI))
{
    PASRC pAsrc = (PASRC)(NEARPTR)dwAPI;

	TraceString ("AsrcDestructor:...\n");

    if (!pAsrc) 
	{
		TraceString ("AsrcDestructor: Bad dwAPI\n");
		return 0;
	}

	osdepDelete (pAsrc);

    IAsrcDestructor (pAsrc);    
    if (pAsrc->m_pShared)
    {
    	MyFree (pAsrc->m_pShared);
    	pAsrc->m_pShared = NULL;
    }
    MyFree (pAsrc);
    return 0;
}

//extern "C" 
int FAR PASCAL WEP(int n)
{
    /* Your WEP functionality goes here */
    return 1;
}