/*---------------------------------------------------------------------------*
  Project:  Host I/O Interface for HIO2
  File:     Hio2IfHost.h

  (C)2005 HUDSON SOFT

  $Header: /home/cvsroot/SDK/build/demos/hio2demo/vc++/HioIf/include/Hio2IfHost.h,v 1.3 2006/03/15 06:31:25 mitu Exp $

  $NoKeywords: $
 *---------------------------------------------------------------------------*/

// HIO2 API wrapper interface

#pragma	once

#include <revolution/hio2.h>
#include <win32/mytl.h>	// NNGC SDK : $(ROOT)/include/win32
#include "Hio2If.h"		// ../../HioIf/include
#include "Hio2DllIf.h"

///////////////////////////////////////////////////////////////////////////////
//
// Use for CHio2If internal processing (private)
//

#define	HIO2IF_INVALID_HANDLE_VALUE	((LPVOID)-1)

// Host I/O interface state
typedef struct _HIO2IF_STATUS
{
	_HIO2IF_STATUS()
	{
		m_nPcChan = HIO2IF_INVALID_ID;
		m_nDevType = HIO2_DEVICE_INVALID;
		m_hHIO	= HIO2IF_INVALID_HANDLE_VALUE;
		m_nMode	= HIO2IF_MODE_NONE;
		m_bConnect	= FALSE;
		m_bReceived	= FALSE;
		m_bSendPossible = TRUE;
		m_dwAsyncMode = 0;
		m_fncCallback = NULL;
#ifndef	HW0
		m_pPathName = NULL;
#else	// HW0
		m_pPathName = -1;
#endif	// HW0
	}

	~_HIO2IF_STATUS()
	{
#ifndef	HW0
		if ( m_pPathName != NULL ) delete [] m_pPathName;
#endif	// HW0
	}

	HIO2DevicePath	m_pPathName;		// device path name
	int				m_nPcChan;			// PC channel (simulated by CHio2If)
	HIO2DeviceType	m_nDevType;			// EXI device type
	LPVOID			m_hHIO;				// Host I/O API handle
	HIO2IF_MODE		m_nMode;			// open mode
	volatile BOOL	m_bConnect;			// NNGC connection state
	volatile BOOL	m_bReceived;		// data receipt notification from NNGC
	volatile BOOL	m_bSendPossible;	// sending to NNGC possible
	volatile DWORD	m_dwAsyncMode;		// async mode
	HIO2IF_EVENT_CALLBACK	m_fncCallback;	// callback function when event is received
} HIO2IF_STATUS, *LPHIO2IF_STATUS;

// Host I/O interface state listing and comparison function
//
// * the index for this class is HIO2IF_ID gotten by CHio2If->Open()
//

typedef TMYList<LPHIO2IF_STATUS>	CStatusList;

// the comparison function specified in CtatusList.IndexOf()
BOOL	Hio2IfCompHandle(LPHIO2IF_STATUS pItem, LPVOID pData);
BOOL	Hio2IfCompPcChan(LPHIO2IF_STATUS pItem, LPVOID pData);

///////////////////////////////////////////////////////////////////////////////
//
// CHio2If
//

// Host I/O interface for PC

class CHio2If
{
public:
	CHio2If();
	~CHio2If();

	// device path information referencing method
	int	GetDeviceCount()	const { return (int)m_cDevices.size();	}
	HIO2DevicePath	GetDevicePath(int nIndex)	const
	{
		ASSERT((nIndex >= 0) && (nIndex < (int)m_cDevices.size()));
		return m_cDevices[nIndex];
	}

	// HIO2 API control method
	HIO2IF_RESULT	Init();
	HIO2IF_RESULT	Open(HIO2DevicePath pathName, HIO2IF_EVENT_CALLBACK callback, HIO2IF_ID& id);
	HIO2IF_RESULT	Read(HIO2IF_ID id, DWORD addr, LPVOID buffer, int size, BOOL async);
	HIO2IF_RESULT	ReadFree(HIO2IF_ID id, DWORD addr, LPVOID buffer, int size, BOOL async);
	HIO2IF_RESULT	Write(HIO2IF_ID id, DWORD addr, LPVOID buffer, int size, BOOL async);
	HIO2IF_RESULT	WriteFree(HIO2IF_ID id, DWORD addr, LPVOID buffer, int size, BOOL async);
	HIO2IF_RESULT	ReadStatus(HIO2IF_ID id, DWORD& status);
	HIO2IF_RESULT	Close(HIO2IF_ID id);
	void			Exit();

	// state referencing method
	BOOL	IsConnected(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_bConnect : FALSE;
	}
	BOOL	IsReceived(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_bReceived : FALSE;
	}
	BOOL	IsSendPossible(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_bSendPossible : FALSE;
	}
	HIO2IF_MODE	GetOpenMode(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_nMode : HIO2IF_MODE_NONE;
	}
	int	GetPcChan(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_nPcChan : HIO2IF_INVALID_ID;
	}
	HIO2DeviceType	GetDeviceType(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_nDevType : HIO2_DEVICE_INVALID;
	}

	// method for multi-threaded application
	void	EnterCriticalSection()	{ ::EnterCriticalSection(&m_csCriticalSection); }
	void	LeaveCriticalSection()	{ ::LeaveCriticalSection(&m_csCriticalSection); }

	// method for getting error information
	HIO2IF_ERROR	GetLastError()	const { return m_nLastError;	}
	LPCSTR	GetMessage()			const { return m_szMessage;		}

	//!!!!!!!!!! method whose use is forbidden in applications!!!!!

	CHio2DllIf&	GetDllIf()	{ return m_cHio2Dll;	};
	void	SetDeviceType(HIO2IF_ID id, HIO2DeviceType type)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_nDevType = type;
	};
	void	SetOpenMode(HIO2IF_ID id, HIO2IF_MODE mode)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_nMode = mode;
	};
	void	SetConnect(HIO2IF_ID id, BOOL bStatus)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_bConnect = bStatus;
	};
	void	SetReceived(HIO2IF_ID id, BOOL bStatus)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_bReceived = bStatus;
	};
	void	SetSendPossible(HIO2IF_ID id, BOOL bStatus)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_bSendPossible = bStatus;
	};
	DWORD	GetAsyncMode(HIO2IF_ID id)
	{
		return IsValidID(id) ? m_cHioStatus[id]->m_dwAsyncMode : 0;
	};
	void	SetAsyncMode(HIO2IF_ID id, DWORD mode)
	{
		if ( IsValidID(id) ) m_cHioStatus[id]->m_dwAsyncMode = mode;
	}
	void	CallEventCallback(HIO2IF_ID id, HIO2IF_EVENT event)
	{
		if ( (IsValidID(id)) && (m_cHioStatus[id]->m_fncCallback != NULL) )
			m_cHioStatus[id]->m_fncCallback(id, event);
	}
	int	GetIdOfHandle(LPVOID h)
	{
		return m_cHioStatus.IndexOf(h,Hio2IfCompHandle);
	}
	void	AddDevicePath(HIO2DevicePath pathName);

protected:
	BOOL	m_bInitialized;					// initialization determining flag

	deque<HIO2DevicePath>	m_cDevices;		// device path information
	CStatusList	m_cHioStatus;				// status information

	HIO2IF_ERROR	m_nLastError;			// Error Codes
	TCHAR	m_szMessage[128];				// Error messages

	CRITICAL_SECTION	m_csCriticalSection;	// for multi-threaded applications

	CHio2DllIf	m_cHio2Dll;	// hio2[D].dll interface

	static LPCSTR	m_lpszErrorStrings[HIO2IF_ERROR_MAX];	// Error messages

	void	InitInstance();

	BOOL	IsValidID(HIO2IF_ID id)
	{
		return ((id >= 0) && (id < m_cHioStatus.GetCount())) ? TRUE : FALSE;
	};

	// (Fatal)Error message settings
	HIO2IF_RESULT	SetFatal(HIO2IF_ERROR errID, ...);
	HIO2IF_RESULT	SetError(HIO2IF_ERROR errID, ...);
};

//-----------------------------------------------------------------------------
// function prototypes

// create Host I/O interface for PC
CHio2If*	Hio2CreateInterface(void);

// release Host I/O interface for PC
void	Hio2ReleaseInterface(CHio2If* pHioIf);

// end of Hio2IfHost.h