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

  (C)2005 HUDSON SOFT

  $Header: /home/cvsroot/SDK/build/demos/hio2demo/HioIf/include/Hio2If.h,v 1.2 2006/03/09 12:28:43 yasuh-to Exp $

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

// HIO2 API wrapper interface

#ifndef	__HIO2IF_H__
#define	__HIO2IF_H__

#include <revolution/hio2.h>

#ifdef __cplusplus
extern "C" {
#endif

//-----------------------------------------------------------------------------
// define

#define	HIO2IF_INVALID_ID	-1

// packet command (private)
//  -> packet = ((EXI chan(8bit) << 8) | cmd(8bit))
enum HIO2IF_CMD
{
	HIO2IF_CMD_OPEN_RDONLY = 1,	// NNGC ->  PC
	HIO2IF_CMD_OPEN_WRONLY,		// NNGC ->  PC
	HIO2IF_CMD_OPEN_RDWR,		// NNGC ->  PC
	HIO2IF_CMD_OPEN_RESULT,		// NNGC <-  PC
	HIO2IF_CMD_SEND,			// NNGC <-> PC
	HIO2IF_CMD_SEND_RESULT,		// NNGC <-> PC
	HIO2IF_CMD_CLOSE,			// NNGC <-> PC

	HIO2IF_CMD_MASK = 0xFF
};

// async mode (private)
enum HIO2IF_ASYNC
{
	HIO2IF_ASYNC_NONE		= 0x00000000,
	HIO2IF_ASYNC_READ		= 0x00000001,
	HIO2IF_ASYNC_READ_FREE	= 0x00000002,
	HIO2IF_ASYNC_WRITE		= 0x00000004,
	HIO2IF_ASYNC_WRITE_FREE	= 0x00000008
};

//-----------------------------------------------------------------------------
// type definition

// ID
typedef int	HIO2IF_ID;

// open mode
typedef enum
{
	HIO2IF_MODE_NONE = -1,
	HIO2IF_MODE_RDONLY,		// receive only
	HIO2IF_MODE_WRONLY,		// send only
	HIO2IF_MODE_RDWR		// send and receive
} HIO2IF_MODE;

// interface result
typedef enum
{
	HIO2IF_RESULT_FATAL = -1,	// error generated in HIO2 API
	HIO2IF_RESULT_SUCCESS,		// Succeeded
	HIO2IF_RESULT_ERROR			// error (different mode, etc.)
} HIO2IF_RESULT;

// event
typedef enum
{
	HIO2IF_EVENT_CONNECT,			// Connection complete
	HIO2IF_EVENT_DISCONNECT,		// connection released
	HIO2IF_EVENT_RECEIVED,			// Receive data
	HIO2IF_EVENT_SEND_POSSIBLE,		// send possible (connection target receiving data)
	HIO2IF_EVENT_READ_ASYNC_DONE,	// Read Async has terminated
	HIO2IF_EVENT_WRITE_ASYNC_DONE,	// Write Async has terminated
	HIO2IF_EVENT_INTERRUPT,			// Hot swapping interrupt generated (NNGC only)
	HIO2IF_EVENT_UNKOWN
} HIO2IF_EVENT;

// event callback
typedef void	(* HIO2IF_EVENT_CALLBACK)(HIO2IF_ID id, HIO2IF_EVENT event);

// error code
typedef enum
{
	// error
	HIO2IF_ERROR_NONE = 0,
	HIO2IF_ERROR_CHAN_NOT_FIND,
	HIO2IF_ERROR_CHAN_ALREADY_OPENED,
	HIO2IF_ERROR_NOT_CONNECT,
	HIO2IF_ERROR_WRITE_ONLY,
	HIO2IF_ERROR_READ_ONLY,
	HIO2IF_ERROR_NOT_RECV_DATA,
	HIO2IF_ERROR_CANNOT_SEND_DATA,
	HIO2IF_ERROR_BUSY,
	HIO2IF_ERROR_INVALID_ID,

	// fatal error
	HIO2IF_FATAL_ENUMDEVICES,
	HIO2IF_FATAL_INIT,
	HIO2IF_FATAL_OPEN,
	HIO2IF_FATAL_CLOSE,
	HIO2IF_FATAL_READ,
	HIO2IF_FATAL_WRITE,
	HIO2IF_FATAL_READSTATUS,
	HIO2IF_FATAL_LOAD_DLL,	// PC only

	HIO2IF_ERROR_MAX
} HIO2IF_ERROR;

// Host I/O interface

#ifndef	WIN32

// status (private)
typedef struct
{
	HIO2DeviceType	nType;					// HIO2 device type
	s32				nPc;					// (pseudo-) USB device number
	HIO2Handle		hHIO;					// HIO2 API handle
	HIO2IF_MODE		nMode;					// open mode
	volatile BOOL	bConnect;				// PC connection state
	volatile BOOL	bReceived;				// data receipt notification from PC
	volatile BOOL	bSendPossible;			// sending to PC possible
	volatile u32	dwAsyncMode;			// async mode
	volatile void*	pReadAsyncPtr;			// buffer specified by Read Async
	volatile u32	dwReadAsyncSize;		// size specified by Read Async
	HIO2IF_EVENT_CALLBACK	fncCallback;	// callback function when event is received
} HIO2IF_STATUS;

// Host I/O interface for NNGC (function prototypes)

// EXI channel information referencing function
s32				HIO2IFGetDeviceCount	( void );
HIO2DeviceType	HIO2IFGetDevice			( s32 index );

// HIO2 API control function
HIO2IF_RESULT	HIO2IFInit				( void );
HIO2IF_RESULT	HIO2IFOpen				( HIO2DeviceType type, HIO2IF_MODE mode, HIO2IF_EVENT_CALLBACK callback, HIO2IF_ID* id );
HIO2IF_RESULT	HIO2IFRead				( HIO2IF_ID id, u32 addr, void* buffer, s32 size, BOOL async );
HIO2IF_RESULT	HIO2IFReadFree			( HIO2IF_ID id, u32 addr, void* buffer, s32 size, BOOL async );
HIO2IF_RESULT	HIO2IFWrite				( HIO2IF_ID id, u32 addr, void* buffer, s32 size, BOOL async );
HIO2IF_RESULT	HIO2IFWriteFree			( HIO2IF_ID id, u32 addr, void* buffer, s32 size, BOOL async );
HIO2IF_RESULT	HIO2IFReadStatus		( HIO2IF_ID id, u32* status );
HIO2IF_RESULT	HIO2IFClose				( HIO2IF_ID id );
void			HIO2IFSync				( void );
void			HIO2IFExit				( void );

// status referencing function
BOOL			HIO2IFIsConnected		( HIO2IF_ID id );
BOOL			HIO2IFIsReceived		( HIO2IF_ID id );
BOOL			HIO2IFIsSendPossible	( HIO2IF_ID id );
HIO2DeviceType	HIO2IFGetDeviceType		( HIO2IF_ID id );
s32				HIO2IFGetPcChan			( HIO2IF_ID id );

// function to get error information
HIO2IF_ERROR	HIO2IFGetLastError		( void );
const char*		HIO2IFGetErrorMessage	( void );

#endif	// WIN32

//-----------------------------------------------------------------------------
// macro definition

// packet (private)
#define	HIO2IF_SET_PACKET(data, cmd)	((u32)(((data) << 8) | (cmd)))
#define	HIO2IF_GET_PACKET_CMD(packet)	((packet) & HIO2IF_CMD_MASK)
#define	HIO2IF_GET_PACKET_CHAN(packet)	(s32)(((packet) >> 8) & HIO2IF_CMD_MASK)

// fatal error check 
#define	HIO2IF_FAILED(result)	\
	(((result) == HIO2IF_RESULT_FATAL) ? TRUE : FALSE)

#define	HIO2IF_SUCCESS(result)	\
	(((result) == HIO2IF_RESULT_SUCCESS) ? TRUE : FALSE)

// async mode check (private)
#define	HIO2IF_ASYNC_READ_MASK(mode)	\
	((mode) & (HIO2IF_ASYNC_READ | HIO2IF_ASYNC_READ_FREE))
#define	HIO2IF_ASYNC_WRITE_MASK(mode)	\
	((mode) & (HIO2IF_ASYNC_WRITE | HIO2IF_ASYNC_WRITE_FREE))

#ifdef __cplusplus
}
#endif
#endif	// __HIO2IF_H__