/*
 * Copyright (c) 2017, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#include "WlctPciAcss.h"
#include "WlctPciAcssHelper.h"
#include "wlct_os.h"
#include "DeviceAccess.h"
#include "PciDeviceAccess.h"
#ifdef _WINDOWS
#include "JtagDeviceAccess.h"
#include "SerialDeviceAccess.h"
#endif
#include "MemoryAccess.h"
#include "Util.h"

#ifdef _WINDOWS
#define WIGIG_REGISTRY_PATH _T("Software\\QualcommAtheros\\WIGIG")
#endif

using namespace std;

#define WLCT_IFACE_NAME_LEN 256
#define BL_READY_TIMEOUT_MS 1000
#define BL_READY_WAIT_INTERVAL_MS 20

WLCTPCIACSS_API int GetMyVersion(WLCT_DLL_VERSION *pVer)
{
	return GetPciAcssVersion(pVer);
}

WLCTPCIACSS_API bool wPciDisableEnable()
{
	return Util::ICHDisableEnable();
}

// return 0 for success
WLCTPCIACSS_API int GetInterfaces(INTERFACE_LIST* ifList, int* ReturnItems)
{
	*ReturnItems = 0;
//	int ret = 0;
#ifdef _WINDOWS
#ifndef NO_JTAG
	if (!jtagLoaded) {
		if (!load_jtag_dll()) {
			printf("jTag DLL were not found, skipping jTag interfaces...\n");
		}
	}
#endif
#endif

	for (int i = 0; i < MAX_INTERFACES; i++)
	{
		memset(ifList->list[i].ifName, 0, MAX_IF_NAME_LENGTH);
	}

#ifdef _WINDOWS
	LOG_MESSAGE_INFO(_T("Checking registry for SkipSerialInterfaces register"));
	DWORD dwSkip = Util::ReadRegistrySettings(WIGIG_REGISTRY_PATH, _T("SkipSerialInterfaces"));
	if (dwSkip == (DWORD)-1)
	{
		LOG_MESSAGE_INFO(_T("SkipSerialInterfaces not found, adding registry key with default set to skip serial interfaces scan"));
		dwSkip = 0;
		Util::WriteRegistrySettings(WIGIG_REGISTRY_PATH, _T("SkipSerialInterfaces"), dwSkip);
	}
	else if (dwSkip == 0)
	{
		LOG_MESSAGE_INFO(_T("Get Interfaces for Serial"));
		GetSerialInterfaces(ifList, ReturnItems);
	}
	else
	{
		LOG_MESSAGE_INFO(_T("SkipSerialInterfaces registry key found, skipping serial interface scan"));
	}
#endif

	LOG_MESSAGE_INFO(_T("Get Interfaces for PCI"));
	GetPciInterfaces(ifList, ReturnItems);

#ifdef _WINDOWS
#ifndef NO_JTAG
	if (jtagLoaded)
	{
		LOG_MESSAGE_INFO(_T("Get Interfaces for jTag"));
		GetJtagInterfaces(ifList, ReturnItems);
	}
#endif

#ifndef NO_SERIAL
	//GetSerialInterfaces(ifList, ReturnItems);
#endif

#endif

	printf("Found %d interfaces \n",*ReturnItems);

	return 0;
}

WLCTPCIACSS_API int StrGetInterfaces(char* ifListStr, int capacity)
{
    INTERFACE_LIST ifList;
    int ReturnItems;
    int ret = GetInterfaces(&ifList, &ReturnItems);
    WLCT_UNREFERENCED_PARAM(ret);

    std::ostringstream ifListBuilder;

    for (int item = 0; item < ReturnItems; item++)
    {
        ifListBuilder << ifList.list[item].ifName << ' ';
    }

    int ifListActualLength = _snprintf(ifListStr, capacity, "%s", ifListBuilder.str().c_str());
    if (ifListActualLength >= capacity)
    {
        LOG_MESSAGE_ERROR(
            _T("Error filling interface list: %S, insufficient buffer capacity: %d\n"),
            ifListBuilder.str().c_str(), capacity);
        return 1;
    }

    LOG_MESSAGE_INFO(_T("Interfaces returned: %S"), ifListStr);
    return 0;
}

//	NAME OF FUNCTION: CreateDeviceAccessHandler
//	CREDIT:
//	PURPOSE:
//		The function will create and will initialize an access of read and write
//		to Wilocity hardware. According to tchDeviceName it will interpret the
//		access type (COM port, PCIe driver or Jtag)
//
//	PARAMETERS:
//	name				type	value/reference		description
// ---------------------------------------------------------------------
//	tchDeviceName    TCHAR*  reference			the name of the access interface
//	devType			int		value				the hardware type (MARLON)
//
//	RETURN VALUE:
//	name         type	description
//	handle / pointer to the access object.
//
//	NOTE:
//		After calling this
// ---------------------------------------------------------------------
//	func return	void*	the overall total enrollment for the university
//
//	CALLS TO: This is a factory method. According to the device name it interprets
//		the right interface and create a new object.
//
// CALLED FROM: main
//
// METHOD: The following is a factory.

WLCTPCIACSS_API int CreateDeviceAccessHandler(const char* deviceName, DType devType, void** pDeviceAccess)
{
	LOG_STACK_ENTER;
	IDeviceAccess* pIDeviceAccss = NULL;
	const TCHAR* const delimit = _T("!");

	TCHAR *tchDeviceName;

	TCHAR *next_token = NULL;
	DType devTypeFromInterface = devType;
	TCHAR tchInterfaceName[WLCT_IFACE_NAME_LEN];
	TCHAR tchOriginalInterfaceName[WLCT_IFACE_NAME_LEN];

    // tchInterfaceName may be not null-terminated after calling _tcscpy_s()
	_tcscpy_s(tchInterfaceName, WLCT_IFACE_NAME_LEN, TSTR_ARG(deviceName));
	tchInterfaceName[WLCT_IFACE_NAME_LEN - 1] = '\0';

	_tcscpy_s(tchOriginalInterfaceName, WLCT_IFACE_NAME_LEN, TSTR_ARG(deviceName));
	//tchOriginalInterfaceName[WLCT_IFACE_NAME_LEN - 1] = '\0';

	LOG_MESSAGE_INFO(_T("CreateDeviceAccessHandler for interface named: %s"), tchInterfaceName);

	tchDeviceName = _tcstok_s( tchInterfaceName, delimit, &next_token);

	if (!tchDeviceName)
	{
		LOG_MESSAGE_ERROR(_T("No device name found"));
		return WLCT_OS_ERROR_NOT_SUPPORTED;
	}

	if (_tcsstr(tchDeviceName, _T("wPci")) == tchDeviceName ||
            _tcsstr(tchDeviceName, _T("wpci")) == tchDeviceName)
	{
            if (devTypeFromInterface != devType)
            {
                return WLCT_OS_ERROR_NOT_SUPPORTED;
            }
			LOG_MESSAGE_INFO(_T("wPci Interface detected"));
            pIDeviceAccss = new CPciDeviceAccess(tchDeviceName, devType);
	}
	else if (_tcsstr(tchDeviceName, _T("wMp")) == tchDeviceName ||
            _tcsstr(tchDeviceName, _T("wmp")) == tchDeviceName)
	{
            if (devTypeFromInterface != devType)
            {
                return WLCT_OS_ERROR_NOT_SUPPORTED;
            }
			LOG_MESSAGE_INFO(_T("wMp Interface detected"));
            pIDeviceAccss = new CPciDeviceAccess(tchDeviceName, devType);
	}
	else if (_tcsstr(tchDeviceName, _T("wEP")) == tchDeviceName ||
            _tcsstr(tchDeviceName, _T("wep")) == tchDeviceName)
	{
			LOG_MESSAGE_INFO(_T("wEP Interface detected"));
            pIDeviceAccss = new CPciDeviceAccess(tchOriginalInterfaceName, devType);
	}
	else if (_tcsstr(tchDeviceName, _T("wController")) == tchDeviceName ||
            _tcsstr(tchDeviceName, _T("wcontroller")) == tchDeviceName)
	{
            if (devTypeFromInterface != devType)
            {
                return WLCT_OS_ERROR_NOT_SUPPORTED;
            }
			LOG_MESSAGE_INFO(_T("wController Interface detected"));
            pIDeviceAccss = new CPciDeviceAccess(tchDeviceName, devType);
	}	// acceptable format is: com3, COM3
	else if (_tcsstr(tchDeviceName, _T("COM")) == tchDeviceName ||
            _tcsstr(tchDeviceName, _T("com")) == tchDeviceName)
	{
		if (devTypeFromInterface != devType)
		{
			return WLCT_OS_ERROR_NOT_SUPPORTED;
		}

#ifdef _WINDOWS
		pIDeviceAccss = new CSerialDeviceAccess(tchDeviceName, devType);
		pIDeviceAccss->SetLastError(0);
#else
                return WLCT_OS_ERROR_NOT_SUPPORTED;
#endif
	}
	else /*if (_tcsicmp(tchDeviceName, _T("wjtag")) == 0)*/
	{
            if (devTypeFromInterface != devType)
            {
                return WLCT_OS_ERROR_NOT_SUPPORTED;
            }
#ifdef _WINDOWS
#ifndef NO_JTAG
            pIDeviceAccss = new CJtagDeviceAccess(tchDeviceName, devType);
            if (pIDeviceAccss->lastError == WLCT_OS_ERROR_OPEN_FAILED)
            {
                printf("JTAG CJtagDeviceAccess creation failed!\n");
                return WLCT_OS_ERROR_NOT_SUPPORTED;
            }
#endif
#else
            return WLCT_OS_ERROR_NOT_SUPPORTED;
#endif
	}

        // Sanity check - pIDeviceAccss should be set according to the access type in the above block
        if (!pIDeviceAccss)
        {
            LOG_MESSAGE_ERROR(_T("No device access handler is set"));
            return WLCT_OS_ERROR_NOT_SUPPORTED;
        }

	// assume device type = unknown and search for correct device type
	pIDeviceAccss->SetDeviceStep(STEP_NONE);

	DWORD rev_id_address = 0x880B34;
	DWORD dft_signature_address = 0x800C;
	DWORD val = 0;

	int ret = WlctAccssRead(pIDeviceAccss, rev_id_address, val);
	LOG_MESSAGE_INFO(_T("RevID on [%S] is [0x%X]"),deviceName,val);
	if (ret == 0 && val != 0xFFFFFFFF)
	{
		if (devType == MST_MARLON)
		{
			if (val == 0x612072F)
			{
				pIDeviceAccss->SetDeviceStep(MARLON_STEP_B0);
				LOG_MESSAGE_INFO(_T("MARLON STEP B0"));
			}

			/* This is not really Marlon, it is a DFT device and it should have
				been a different gateway (not a step inside Marlon) */
			else if (val == 0x0) // DFT
			{
				int ret = WlctAccssRead(pIDeviceAccss, dft_signature_address, val);
				if (ret == 0 && val == 0xCE4)
				{
					pIDeviceAccss->SetDeviceStep(DFT_STEP);
					LOG_MESSAGE_INFO(_T("DFT STEP"));
				}
			}
			else
			{

				//for now always use marlon as B0

				// Device doesn't match the device type MST_MARLON
				LOG_MESSAGE_INFO(_T("NOT Marlon, RevID = [0x%X], closing handler.."),val);
				pIDeviceAccss->CloseDevice();
				return WLCT_OS_ERROR_NOT_SUPPORTED;
			}
		}
		else if (devType == MST_SPARROW)
		{
			if (val == 0x0632072F)
			{
				pIDeviceAccss->SetDeviceStep(SPARROW_STEP_A0);
				LOG_MESSAGE_INFO(_T("SPARROW STEP A0"));
			}
			else if(val == 0x1632072F)
			{
				pIDeviceAccss->SetDeviceStep(SPARROW_STEP_A1);
				LOG_MESSAGE_INFO(_T("SPARROW STEP A1"));
			}
			else if (val == 0x2632072F)
			{
				pIDeviceAccss->SetDeviceStep(SPARROW_STEP_B0);
				LOG_MESSAGE_INFO(_T("SPARROW STEP B0"));
			}
			else
			{
				LOG_MESSAGE_INFO(_T("Unknown RevID = [0x%X] "),val);
				// This case is for future unrecognized devices, for example, MST_NONE
				pIDeviceAccss->SetDeviceStep(STEP_NONE);
				LOG_MESSAGE_INFO(_T("UNKNOWN DEVICE found, assuming it is Sparrow's next step"));
				//pIDeviceAccss->CloseDevice();
				//return WLCT_OS_ERROR_NOT_SUPPORTED;
			}
		}
	}
	else
	{
		pIDeviceAccss->SetLastError(-1);
	}

	*pDeviceAccess = (void*)pIDeviceAccss;
	return pIDeviceAccss->GetLastError();
}

WLCTPCIACSS_API int CloseDeviceAccessHandler(void* pDeviceAccss)
{
	int res = 0;
	IDeviceAccess* pIDevice = (IDeviceAccess*)pDeviceAccss;
	if (pIDevice != NULL)
	{
		__TRY
		{
			pIDevice->CloseDevice();
            #ifdef _WINDOWS
            delete pIDevice;
            #else
			pIDevice = NULL;
            #endif
		}
		__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
		{
			LOG_MESSAGE_ERROR(_T("got exception"));
			res = -1;
		}
	}
	return res;
}

#ifdef _WINDOWS
WLCTPCIACSS_API int WlctAccssSetDriverMode(void* pDeviceAccss, int newState, int & oldState, int &payloadResult){
	if(pDeviceAccss == NULL){
		return -1;
	}
	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		LOG_MESSAGE_ERROR(_T("Could not get lock for PCI access"));
		return -1;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->SetDriverMode(newState, oldState, payloadResult);
		else
			res = -1;

	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception on Mode Change"));
		res = -1;
		oldState = -1;
	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}
	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
		return res;
}

WLCTPCIACSS_API int WlctAccssGetDriverMode(void* pDeviceAccss, int & oldState){
	if(pDeviceAccss == NULL){
		return -1;
	}
	int res = 0;
	int got_resource;
	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		LOG_MESSAGE_ERROR(_T("Could not get lock for PCI access"));
		return -1;
	}
	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->GetDriverMode(oldState);
		else
			res = -1;

	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception on Mode Change"));
		res = -1;
		oldState = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}
	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}
#endif //_WINDOWS

WLCTPCIACSS_API int WlctAccssRead(void* pDeviceAccss, DWORD addr, DWORD & val)
{
	if (pDeviceAccss == NULL)
		return -1;

	if (addr == BAUD_RATE_REGISTER)
		if (((IDeviceAccess*)pDeviceAccss)->GetDeviceStep() == DFT_STEP)
		{
			DWORD baud_rate = 350; // expected baud rate value from DFT
			val = baud_rate;
			return 0;
		}

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		res = accssRead(pDeviceAccss, addr, val);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	LOG_MESSAGE_DEBUG(_T("%S [addr 0x%X] [val %d]"), __FUNCTION__, addr, val);
	return res;
}

WLCTPCIACSS_API int accssRead(void* pDeviceAccss, DWORD addr, DWORD & val) {

	return ((IDeviceAccess*)pDeviceAccss)->r32(addr, val);
}


WLCTPCIACSS_API int WlctAccssAllocPmc(void* pDeviceAccss, DWORD size, DWORD numOfDescriptors)
{
	if (pDeviceAccss == NULL)
        {
            LOG_MESSAGE_ERROR(_T("Cannot allocate PMC descriptors - No device access handler"));
            return -1;
        }

	// Get Resource
	int got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
            LOG_MESSAGE_ERROR(_T("Cannot allocated PMC descriptors - Cannot obtain a lock"));
            return -1;
	}

        int res = 0;
	__TRY
	{
		res = ((IDeviceAccess*)pDeviceAccss)->alloc_pmc(size, numOfDescriptors);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
            LOG_MESSAGE_ERROR(_T("Cannot allocated PMC descriptors - Got exception"));
            res = -1;
            ((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	LOG_MESSAGE_DEBUG(_T("Allocated PMC descriptors. status: %d"), res);
	return res;
}

WLCTPCIACSS_API int SwReset(void* pDeviceAccss)
{
	UINT32 bootLoadReady;
	UINT i, maxIterations;
	USER_RGF_BL_INFO_VER_0 blInfo;

	DWORD readVal;
	int res = 0;

	LOG_MESSAGE_INFO(_T("SwReset Initiated..."));

	/* Clear MAC link up */
	accssSet32(pDeviceAccss, USER_RGF_HP_CTRL, BIT(15));
	accssSet32(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_MASK_0, BIT(6));	/* hpal_perst_from_pad_src_n_mask */
	accssSet32(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_MASK_0, BIT(7));	/* car_perst_rst_src_n_mask */

	/* Halt CPU */
	accssWrite(pDeviceAccss, USER_RGF_USER_CPU_0, BIT(1));
	accssWrite(pDeviceAccss, USER_RGF_MAC_CPU_0, BIT(1));


	/* clear all boot loader "ready" bits */
	accssWrite(pDeviceAccss, USER_RGF_BL_READY, 0); //USER_RGF_BL_READY

	/* Clear Fw Download notification */
	accssClear32(pDeviceAccss, USER_RGF_USAGE_6, BIT(0)); //USER_RGF_USAGE_6)

	// Sparrow only register configuration
	accssSet32(pDeviceAccss, USER_RGF_CAF_OSC_CONTROL, BIT_CAF_OSC_XTAL_EN); //USER_RGF_CAF_OSC_CONTROL


	LOG_MESSAGE_INFO(_T("Sleep: waiting for XTAL stabilization..."));
	/* XTAL stabilization should take about 3ms */
	sleep_ms(XTAL_STABLE_WAIT_MS);
	LOG_MESSAGE_INFO(_T("Sleep done: Checking XTAL stabilization..."));
	res = accssRead(pDeviceAccss, USER_RGF_CAF_PLL_LOCK_STATUS, readVal);	//USER_RGF_CAF_PLL_LOCK_STATUS

	if (!(readVal & BIT_CAF_OSC_DIG_XTAL_STABLE)) {	//BIT_CAF_OSC_DIG_XTAL_STABLE
            LOG_MESSAGE_ERROR(_T("%s: BIT_CAF_OSC_DIG_XTAL_STABLE=0x%x\n"), __FUNCTION__, BIT_CAF_OSC_DIG_XTAL_STABLE);
            LOG_MESSAGE_ERROR(_T("%s: Xtal stabilization timeout USER_RGF_CAF_PLL_LOCK_STATUS val=0x%x\n"), __FUNCTION__, readVal);
            return -1;
	}

	/* switch 10k to XTAL*/
	accssClear32(pDeviceAccss, USER_RGF_SPARROW_M_4, BIT_SPARROW_M_4_SEL_SLEEP_OR_REF); //USER_RGF_SPARROW_M_4

	/* 40 MHz */
	accssClear32(pDeviceAccss, USER_RGF_CLKS_CTL_0, BIT_USER_CLKS_CAR_AHB_SW_SEL);  //USER_RGF_CLKS_CTL_0


	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_0, 0x3ff81f); //USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_0
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_1, 0xf);	//USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_1

	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_2, 0xFE000000);	//USER_RGF_CLKS_CTL_SW_RST_VEC_2
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_1, 0x0000003F); //USER_RGF_CLKS_CTL_SW_RST_VEC_1
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_3, 0x000000f0); //USER_RGF_CLKS_CTL_SW_RST_VEC_3
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_0, 0xFFE7FC00);	//USER_RGF_CLKS_CTL_SW_RST_VEC_0

	/* Sparrow Exit SW Reset */
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_0, 0x0);	//USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_0
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_1, 0x0);	//USER_RGF_CLKS_CTL_EXT_SW_RST_VEC_1


	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_2, 0);	//USER_RGF_CLKS_CTL_SW_RST_VEC_2
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_1, 0); //USER_RGF_CLKS_CTL_SW_RST_VEC_1
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_3, 0); //USER_RGF_CLKS_CTL_SW_RST_VEC_3
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_0, 0);	//USER_RGF_CLKS_CTL_SW_RST_VEC_0

	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_3, 0x00000003); //USER_RGF_CLKS_CTL_SW_RST_VEC_3
	/* reset A2 PCIE AHB */
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_2, 0x00008000);	//USER_RGF_CLKS_CTL_SW_RST_VEC_2

	/* TODO: check order here!!! Erez code is different */
	accssWrite(pDeviceAccss, USER_RGF_CLKS_CTL_SW_RST_VEC_0, 0x0);	//USER_RGF_CLKS_CTL_SW_RST_VEC_0

	// Now wait for device ready, use HW_MACHINE register for this
	maxIterations = BL_READY_TIMEOUT_MS / BL_READY_WAIT_INTERVAL_MS;


	LOG_MESSAGE_INFO(_T("Checking bootloader..."));

	for (i = maxIterations; i; --i)
	{

		//First wait to let the register have the stabilization time it needs
		sleep_ms(BL_READY_WAIT_INTERVAL_MS);

		bootLoadReady = accssRead(pDeviceAccss, USER_RGF_BL_READY, readVal);	//USER_RGF_BL_READY
		(void)bootLoadReady;

		if (readVal == BL_BIT_READY)//BL_BIT_READY
		{
			break;
		}
	}

	LOG_MESSAGE_INFO(_T("Wait on register USER_RGF_BL_READY for %d msec\n"), (maxIterations - i)*BL_READY_WAIT_INTERVAL_MS);

	// check for long wait
	if (0 == i)
	{
            LOG_MESSAGE_ERROR(_T("%s: timeout on register USER_RGF_BL_READY\n"), __FUNCTION__);
            return -1;
	}

	// read info from BL
	void* pBlInfo = &blInfo; // keep the address in temporary variable to prevent false positive warning
	hwCopyFromIO(pBlInfo, pDeviceAccss, USER_RGF_BL_START_OFFSET, sizeof(blInfo));


	LOG_MESSAGE_INFO(_T("Boot loader information: Ready=0x%x, StructVersion=0x%x, RfType=0x%x BaseBandType=0x%x\n"),
		blInfo.Ready, blInfo.StructVersion, blInfo.RfType, blInfo.BaseBandType);

	LOG_MESSAGE_INFO(_T("Boot loader macaddr=%02x:%02x:%02x:%02x:%02x:%02x\n"),
		blInfo.MacAddr[0], blInfo.MacAddr[1], blInfo.MacAddr[2],
		blInfo.MacAddr[3], blInfo.MacAddr[4], blInfo.MacAddr[5]);

	accssClear32(pDeviceAccss, USER_RGF_CLKS_CTL_0, BIT_USER_CLKS_RST_PWGD); //USER_RGF_CLKS_CTL_0


	if (blInfo.StructVersion > 0)
	{
		USER_RGF_BL_INFO_VER_1 blInfoVer1;
		// print the BL version
		void* pBlInfo1 = &blInfoVer1; // keep the address in temporary variable to prevent false positive warning
		hwCopyFromIO(pBlInfo1, pDeviceAccss, USER_RGF_BL_START_OFFSET, sizeof(blInfoVer1));

		LOG_MESSAGE_INFO(_T("Boot Loader build %d.%d.%d.%d\n"),
			blInfoVer1.VersionMajor, blInfoVer1.VersionMinor,
			blInfoVer1.VersionSubminor, blInfoVer1.VersionBuild);
	}

	LOG_MESSAGE_INFO(_T("SwReset Done..."));

	return res;
}

WLCTPCIACSS_API int InterfaceReset(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		res = ((IDeviceAccess*)pDeviceAccss)->do_interface_reset();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	LOG_MESSAGE_DEBUG(_T("Interface Reset flow end"));
	return res;
}

/* helper function copied and modified from the driver
	we can use this to read info from the boot loader
*/
WLCTPCIACSS_API void hwCopyFromIO( void* dst, void* pDeviceAccss, DWORD src, UINT32 len)
{
	const size_t regSizeInBytes = 4;
	UINT32 regCount = (len + regSizeInBytes - 1) / regSizeInBytes;
	std::vector<DWORD> readBuffer(regCount);

	for (size_t i = 0U; i < readBuffer.size(); ++i)
	{
		((IDeviceAccess*)pDeviceAccss)->r32(src + i, readBuffer[i]);
	}

	memcpy(dst, &readBuffer[0], len);
}

WLCTPCIACSS_API int WlctAccssWrite(void* pDeviceAccss, DWORD addr, DWORD val)
{
	int res = 0;
	int got_resource;

	if (pDeviceAccss == NULL)
		return -1;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return -1;
	}

	__TRY
	{
		res = accssWrite(pDeviceAccss,addr,val);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	LOG_MESSAGE_DEBUG(_T("%S [addr 0x%X] [val %d]"), __FUNCTION__, addr, val);
	return res;
}

WLCTPCIACSS_API int accssWrite(void* pDeviceAccss, DWORD addr, DWORD val)
{

	return ((IDeviceAccess*)pDeviceAccss)->w32((addr), val);

}

/* accssSet32 is a modifiled write function based on logic from the driver
	First read from the addr
	Set  the readVal to the desired val with |= val
	Write readVal back into addr
*/
WLCTPCIACSS_API int accssSet32(void* pDeviceAccss, DWORD addr, DWORD val) {
	int res = 0;
	DWORD readVal;

	res = accssRead(pDeviceAccss, addr, readVal);
	readVal |= val;
	res = accssWrite(pDeviceAccss, addr, readVal);

	return res;
}

/* accssClear32 is a modifiled write function based on logic from the driver
	First read from the addr
	Clear the readVal to the desired val with &= ~val
	Write readVal back into addr
*/
WLCTPCIACSS_API int accssClear32(void* pDeviceAccss, DWORD addr, DWORD val) {
	int res = 0;
	DWORD readVal;

	res = accssRead(pDeviceAccss, addr, readVal);
	readVal &= ~val;
	res = accssWrite(pDeviceAccss, addr, readVal);

	return res;
}

WLCTPCIACSS_API bool isInit(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return false;

	bool res = 0;
	__TRY
	{
		res = ((IDeviceAccess*)pDeviceAccss)->isInitialized();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = false;
	}
	return res;
}

WLCTPCIACSS_API int writeBlock(void* pDeviceAccss, DWORD addr, DWORD blockSize, const char *arrBlock)
{
	int got_resource;

	if (pDeviceAccss == NULL)
		return -1;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return -1;
	}


	int res = 0;
	__TRY
	{
		LOG_MESSAGE_DEBUG(_T("start running"));
		res = ((IDeviceAccess*)pDeviceAccss)->wb(addr, blockSize, arrBlock);
		LOG_MESSAGE_DEBUG(_T("Leaving"));
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API int readBlock(void* pDeviceAccss, DWORD addr, DWORD blockSize, char *arrBlock)
{
	int got_resource;

	if (pDeviceAccss == NULL)
		return -1;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return -1;
	}


	int res = 0;
	__TRY
	{

		LOG_MESSAGE_DEBUG(_T("start running"));

		res = ((IDeviceAccess*)pDeviceAccss)->rb(addr, blockSize, arrBlock);
		LOG_MESSAGE_DEBUG(_T("Leaving"));
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

//
// read repeat - will read from the same address num_repeat times
// the result will store in arrBlock. arrBlock is an array of shorts with at least num_repeat entries.
//
WLCTPCIACSS_API int readRepeat(void* pDeviceAccss, DWORD addr, DWORD num_repeat, DWORD *arrBlock)
{
	int got_resource;

	if (pDeviceAccss == NULL)
		return -1;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return -1;
	}


	int res = 0;
	__TRY
	{
		LOG_MESSAGE_DEBUG(_T("start running"));
		res = ((IDeviceAccess*)pDeviceAccss)->rr(addr, USHORT(num_repeat), arrBlock);
		LOG_MESSAGE_DEBUG(_T("Leaving"));
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API DType getDeviceType(void* pDeviceAccss)
{
	return ((IDeviceAccess*)pDeviceAccss)->GetDeviceType();
}

WLCTPCIACSS_API int getDbgMsg(void* pDeviceAccss, FW_DBG_MSG** pMsg)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		res = ((IDeviceAccess*)pDeviceAccss)->getFwDbgMsg(pMsg);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int clearAllFwDbgMsg(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((IDeviceAccess*)pDeviceAccss)->clearAllFwDbgMsg();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int card_reset(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((IDeviceAccess*)pDeviceAccss)->do_reset();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int startSampling(void* pDeviceAccss, DWORD* pRegsArr, DWORD regArrSize, DWORD interval, DWORD maxSampling, DWORD transferMethod)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((IDeviceAccess*)pDeviceAccss)->startSampling(pRegsArr, regArrSize, interval, maxSampling, transferMethod);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int stopSampling(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((IDeviceAccess*)pDeviceAccss)->stopSampling();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int getSamplingData(void* pDeviceAccss, DWORD** pDataSamples)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		res = ((IDeviceAccess*)pDeviceAccss)->getSamplingData(pDataSamples);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API TCHAR* getInterfaceName(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return NULL;

	TCHAR* szInfName = NULL;
	__TRY
	{
		szInfName = ((IDeviceAccess*)pDeviceAccss)->GetInterfaceName();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
	}
	return szInfName;
}

#ifdef _WINDOWS
#ifndef NO_JTAG
WLCTPCIACSS_API int WlctAccssJtagSendDR(void* pDeviceAccss, DWORD num_bits, BYTE *arr_in, BYTE *arr_out)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (isInit(pDeviceAccss))
		{
			if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypeJTAG)
			{
				if (((IDeviceAccess*)pDeviceAccss)->GetDeviceType() == MST_MARLON)
				{
					res = ((CJtagDeviceAccess*)pDeviceAccss)->jtag_set_dr(arr_in, arr_out, num_bits);
				}
			}
		}
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	//	LOG_MESSAGE_DEBUG(_T("%S [addr 0x%X] [val %d]"), __FUNCTION__, addr, val);
	return res;
}

WLCTPCIACSS_API int WlctAccssJtagSendIR(void* pDeviceAccss, DWORD num_bits, BYTE *arr_in)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (isInit(pDeviceAccss))
		{
			if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypeJTAG)
			{
				if (((IDeviceAccess*)pDeviceAccss)->GetDeviceType() == MST_MARLON)
				{
					res = ((CJtagDeviceAccess*)pDeviceAccss)->jtag_set_ir(num_bits, arr_in);
				}
			}
		}
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
//	LOG_MESSAGE_DEBUG(_T("%S [addr 0x%X] [val %d]"), __FUNCTION__, addr, val);
	return res;
}

WLCTPCIACSS_API int JtagSetClockSpeed(void* pDeviceAccss, DWORD requestedFreq, DWORD* frqSet)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((CJtagDeviceAccess*)pDeviceAccss)->set_speed(requestedFreq, frqSet);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int JtagPutTmsTdiBits(void* pDeviceAccss, BYTE *tms, BYTE *tdi, BYTE* tdo, UINT length)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	__TRY
	{
		((CJtagDeviceAccess*)pDeviceAccss)->direct_control(tms, tdi, tdo, length);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
	}
	return res;
}

WLCTPCIACSS_API int JtagTmsShiftToReset(void* pDeviceAccss)
{
	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (isInit(pDeviceAccss))
		{
			if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypeJTAG)
			{
				if (((IDeviceAccess*)pDeviceAccss)->GetDeviceType() == MST_MARLON)
				{
					res = ((CJtagDeviceAccess*)pDeviceAccss)->jtag_reset();
				}

				if (((IDeviceAccess*)pDeviceAccss)->GetDeviceType() == MST_SPARROW)
				{
					res = ((CJtagDeviceAccess*)pDeviceAccss)->jtag_reset();
				}
			}
		}
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	//	LOG_MESSAGE_DEBUG(_T("%S [addr 0x%X] [val %d]"), __FUNCTION__, addr, val);
	return res;
}
#else // JTAG

WLCTPCIACSS_API int JtagSetClockSpeed(void* pDeviceAccss, DWORD requestedFreq, DWORD* frqSet)
{
	return -1;
}

WLCTPCIACSS_API int JtagPutTmsTdiBits(void* pDeviceAccss, BYTE *tms, BYTE *tdi, BYTE* tdo, UINT length)
{
	return -1;
}

WLCTPCIACSS_API int JtagTmsShiftToReset(void* pDeviceAccss)
{
	return -1;
}

#endif // ifndef NO_JTAG
#endif /* _WINDOWS */

#ifdef _WINDOWS
WLCTPCIACSS_API int WlctAccssSendWmiCmd(void* pDeviceAccss, SEND_RECEIVE_WMI* wmi)
{
	LOG_MESSAGE_INFO(_T("WlctAccssSendWmiCmd: 0x%X"),  (*wmi).uCmdId);

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->send_wmi_cmd(wmi);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API int WlctAccssRecieveWmiEvent(void* pDeviceAccss, SEND_RECEIVE_WMI* evt)
{
	LOG_MESSAGE_INFO(_T("WlctAccssRecieveWmiEvent"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->recieve_wmi_event(evt);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API int WlctAccssMpSetDriverLogLevels(void* pDeviceAccss, ULONG logModulesEnableMsk, ULONG logModuleLevelsMsk[WILO_DRV_NUM_LOG_COMPS])
{
	LOG_MESSAGE_INFO(_T("WlctAccssMpDriverLogLevels"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->setMpDriverLogLevels(logModulesEnableMsk, logModuleLevelsMsk);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

#endif

WLCTPCIACSS_API int WlctAccssRegisterDriverMailboxEvents(void* pDeviceAccss, HANDLE* pMailboxEventHandle )
{
	LOG_MESSAGE_INFO(_T("WlctAccssRegisterDriverMailboxEvents"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->register_driver_mailbox_event(pMailboxEventHandle);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}


WLCTPCIACSS_API int WlctAccssRegisterDriverDeviceEvents(void* pDeviceAccss, INT_PTR hDnEvent, INT_PTR hUpEvent, INT_PTR hUnplugEvent, INT_PTR hSysAssertEvent )
{
	LOG_MESSAGE_INFO(_T("WlctAccssRegisterDriverDeviceEvents"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->register_driver_device_events (hDnEvent, hUpEvent, hUnplugEvent, hSysAssertEvent);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API int WlctAccssUnregisterDriverDeviceEvents(void* pDeviceAccss){
	LOG_MESSAGE_INFO(_T("WlctAccssUnregisterDriverDeviceEvents"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->unregister_driver_device_events();
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}
WLCTPCIACSS_API int WlctAccssRegisterDriverEvent(void* pDeviceAccss, INT_PTR event_ptr, int eventId, int appId)
{
	LOG_MESSAGE_INFO(_T("WlctAccssRegisterDriverDeviceEvent"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		if (((IDeviceAccess*)pDeviceAccss)->GetType() == IDeviceAccess::ETypePCI)
			res = ((CPciDeviceAccess*)pDeviceAccss)->register_driver_device_event (event_ptr, appId, eventId);
		else
			res = -1;
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;

}


WLCTPCIACSS_API int WlctAccssRegisterDeviceForUnplug2Event(void* pDeviceAccss, INT_PTR event_ptr)
{

	LOG_MESSAGE_INFO(_T("WlctAccssRegisterDeviceForUnplug2Event"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
			res = ((CPciDeviceAccess*)pDeviceAccss)->register_device_unplug2 (event_ptr);
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}

WLCTPCIACSS_API int WlctAccssUnregisterDeviceForUnplug2Event(void* pDeviceAccss)
{

	LOG_MESSAGE_INFO(_T("WlctAccssUnregisterDeviceForUnplug2Event"));

	if (pDeviceAccss == NULL)
		return -1;

	int res = 0;
	int got_resource;

	// Get Resource
	got_resource = Util::timedResourceInterLockExchange(  &((((IDeviceAccess*)pDeviceAccss)->m_flag_busy)), true, 1000, false);
	if (!got_resource)
	{
		return res;
	}

	__TRY
	{
		res = ((CPciDeviceAccess*)pDeviceAccss)->unregister_device_unplug2 ();
	}
	__EXCEPT(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode())
	{
		LOG_MESSAGE_ERROR(_T("got exception"));
		res = -1;
		((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	}

	((IDeviceAccess*)pDeviceAccss)->m_flag_busy = false;
	return res;
}