//
//  Copyright(C) Renesas Technology Corp. 2002-2003. All rights reserved.
//
// GPIO driver for ITS-DS7
//
// FILE     : GPIO.C
// CREATED  : 2002.06.27
// MODIFIED : 2003.06.20
// AUTHOR   : Renesas Technology Corp.
// HARDWARE : RENESAS ITS-DS7
// HISTORY  : 
//            2003.06.20
//            - Created release code.
//              (based on GPIO driver for 
//                        ITS-DS4 Source Kit Ver.1.2.0 for WCE 4.2)
//

#include <windows.h>
#include <types.h>
#include <memory.h>
#include <nkintr.h>
#include <excpt.h>
#include "oalintr.h"
#include "platform.h"
#include "sh7770.h"
#include "gpio.h"
#include "gpiodbg.h"
#include "drv_glob.h"
#include "ioctl_its_ds7.h"

#define GPIO_DRIVER_KEY		TEXT("Drivers\\BuiltIn\\GPIO")
#define ENABLE_GPIO_MODE	TEXT("ENABLE_GPIO_MODE")
#define LOCK_PORT_GPIO0		TEXT("LOCK_PORT_GPIO0")
#define LOCK_PORT_GPIO1		TEXT("LOCK_PORT_GPIO1")
#define LOCK_PORT_GPIO2		TEXT("LOCK_PORT_GPIO2")
#define LOCK_PORT_GPIO3		TEXT("LOCK_PORT_GPIO3")

VOID EventHandler();

HANDLE	hEvent[4][32];

BOOL __stdcall
DllEntry(
	HINSTANCE	hinstDll,			// @param Instance pointer.
	DWORD		dwReason,			// @param Reason routine is called.
	LPVOID		lpReserved			// @param system parameter.
	)
{
	switch( dwReason ){
		case DLL_PROCESS_ATTACH :
			DEBUGREGISTER( hinstDll );
			break;
		case DLL_PROCESS_DETACH :
			break;
		default :
			break;
	}
	return TRUE;
}

//	@func HANDLE | GPI_Init | device initialization routine
//	@parm DWORD  |  Index   | info passed to RegisterDevice
//	@rdesc	Returns a HANDLE which will be passed to Open & Deinit or NULL if
//			unable to initialize to driver.
HANDLE
GPI_Init(
	DWORD	Index
	)
{
	PGPIO_DRIVER_INFO	pGpio;
    DWORD	 			dwType;
	HKEY				hKey;
    DWORD	 			dwModeSize = sizeof(pGpio->dwMode);
    DWORD	 			dwLockSize = sizeof(pGpio->Lock);
	DWORD				dwRet;

	DWORD				dwGpioNum;
	ULONG				ulRegSize;

	pGpio = VirtualAlloc(
					NULL,
					sizeof ( GPIO_DRIVER_INFO ),
					MEM_COMMIT,
					PAGE_READWRITE
					);
	if ( pGpio == NULL ){
		goto ALLOCFAILED;
	}

	pGpio -> pvBase = VirtualAlloc(
						NULL,
						GPIO_REGSIZE,
						MEM_RESERVE, 
						PAGE_NOACCESS);
	if ( pGpio -> pvBase == NULL ){
		goto ALLOCFAILED;
	}
	if ( !VirtualCopy(
					(PVOID)pGpio -> pvBase, 
					(PVOID)GPIO_REGBASE,
					GPIO_REGSIZE,
					PAGE_READWRITE|PAGE_NOCACHE) 
		){
		goto ALLOCFAILED;
	}

	ulRegSize = 0; 

	for (dwGpioNum =0; dwGpioNum < 4; dwGpioNum++){

		pGpio -> IOINTSEL[dwGpioNum]  = pGpio -> pvBase + GPIO_IOINTSEL_OFFSET + ulRegSize;
		pGpio -> INOUTSEL[dwGpioNum]  = pGpio -> pvBase + GPIO_INOUTSEL_OFFSET + ulRegSize;
		pGpio -> OUTDT[dwGpioNum]  = pGpio -> pvBase + GPIO_OUTDT_OFFSET + ulRegSize;
		pGpio -> INDT[dwGpioNum]  = pGpio -> pvBase + GPIO_INDT_OFFSET + ulRegSize;
		pGpio -> INTDT[dwGpioNum]  = pGpio -> pvBase + GPIO_INTDT_OFFSET + ulRegSize;
		pGpio -> INTCLR[dwGpioNum]  = pGpio -> pvBase + GPIO_INTCLR_OFFSET + ulRegSize;
		pGpio -> INTMSK[dwGpioNum]  = pGpio -> pvBase + GPIO_INTMSK_OFFSET + ulRegSize;
		pGpio -> MSKCLR[dwGpioNum]  = pGpio -> pvBase + GPIO_MSKCLR_OFFSET + ulRegSize;
		pGpio -> POSNEG[dwGpioNum]  = pGpio -> pvBase + GPIO_POSNEG_OFFSET + ulRegSize;
		pGpio -> EDGLEVEL[dwGpioNum]  = pGpio -> pvBase + GPIO_EDGLEVEL_OFFSET + ulRegSize;
		pGpio -> FILONOFF[dwGpioNum]  = pGpio -> pvBase + GPIO_FILONOFF_OFFSET + ulRegSize;
		ulRegSize += GPIO_REGSIZE/4; 
	}

    dwRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,GPIO_DRIVER_KEY,0,0,&hKey);
    if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR,(TEXT("GPIO driver : RegOpenKeyEx failed\r\n")));
        return NULL;
    }

    dwRet = RegQueryValueEx(hKey,ENABLE_GPIO_MODE,NULL,&dwType,(PUCHAR)&(pGpio->dwMode),&dwModeSize);
     if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (TEXT("GPIO driver : RegQueryValueEx failed\r\n")));
        return NULL;
    }

    dwRet = RegQueryValueEx(hKey,LOCK_PORT_GPIO0,NULL,&dwType,(PUCHAR)&(pGpio->Lock[0]),&dwLockSize);
     if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (TEXT("GPIO driver : RegQueryValueEx failed\r\n")));
        return NULL;
    }

    dwRet = RegQueryValueEx(hKey,LOCK_PORT_GPIO1,NULL,&dwType,(PUCHAR)&(pGpio->Lock[1]),&dwLockSize);
     if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (TEXT("GPIO driver : RegQueryValueEx failed\r\n")));
        return NULL;
    }

    dwRet = RegQueryValueEx(hKey,LOCK_PORT_GPIO2,NULL,&dwType,(PUCHAR)&(pGpio->Lock[2]),&dwLockSize);
     if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (TEXT("GPIO driver : RegQueryValueEx failed\r\n")));
        return NULL;
    }

    dwRet = RegQueryValueEx(hKey,LOCK_PORT_GPIO3,NULL,&dwType,(PUCHAR)&(pGpio->Lock[3]),&dwLockSize);
     if (dwRet != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR, (TEXT("GPIO driver : RegQueryValueEx failed\r\n")));
        return NULL;
    }  
    

    dwRet = RegCloseKey(hKey);

	for (dwGpioNum = 0; dwGpioNum < 4; dwGpioNum++){
		pGpio->dwLock[dwGpioNum] = pGpio->Lock[dwGpioNum];
	}		

	pGpio -> hThread = CreateThread(
						NULL,
						0,
						(LPTHREAD_START_ROUTINE)EventHandler,
						pGpio,
						0,
						NULL
						);
	if ( pGpio -> hThread == NULL ){
		goto ALLOCFAILED;
	}

	return (HANDLE)pGpio;

ALLOCFAILED:
	if ( pGpio )
		VirtualFree(pGpio, sizeof(GPIO_DRIVER_INFO), MEM_DECOMMIT);
	if ( pGpio -> pvBase )
		VirtualFree((PVOID)pGpio -> pvBase, 0, MEM_RELEASE);
	if ( pGpio -> hThread )
		CloseHandle( pGpio -> hThread );
	return NULL;
}

//	@func BOOL | GPI_Deinit | device deinitialization routine
//	@parm ??
//	@rdesc	Returns TRUE for success, FALSE for failure
BOOL
GPI_Deinit(
	PGPIO_DRIVER_INFO	pGpio
	)
{
	CloseHandle( pGpio -> hThread );
	VirtualFree((PVOID)pGpio -> pvBase, 0, MEM_RELEASE);
	VirtualFree(pGpio, sizeof(GPIO_DRIVER_INFO), MEM_DECOMMIT);

	return TRUE;
}

//	@func HANDLE | GPI_Open    | device open routine
//	@parm DWORD  | dwData      | value returned from GPI_Init call
//	@parm DWORD  | dwAccess    | requested access (combination of GENERIC_READ
//								 and GENERIC_WRITE)
//	@parm DWORD  | dwShareMode | requested share mode (combination of 
//								 FILE_SHARE_READ and FILE_SHARE_WRITE)
//	@rdesc	Returns a HANDLE which will be passed to Read, Write, etc or NULL if
//			unable to open device.
HANDLE
GPI_Open(
	DWORD	dwData,
	DWORD	dwAccess,
	DWORD	dwShareMode
	)
{
	PGPIO_OPEN_INFO pOpen;

	pOpen = LocalAlloc(LPTR,sizeof(GPIO_OPEN_INFO));
	if( pOpen == NULL ){
		return NULL;
	}
	pOpen -> dwAccess = dwAccess;
	pOpen -> dwShareMode = dwShareMode;
	pOpen -> pGPIOHandle = (PGPIO_DRIVER_INFO)dwData;

	return (HANDLE)pOpen;
}

//	@func BOOL | GPI_Close | device close routine
//	@parm ???
//	@rdesc	Returns TRUE for success, FALSE for failure
BOOL
GPI_Close(
	PGPIO_OPEN_INFO pOpen
	)
{
	LocalFree( pOpen );
	return TRUE;
}

//	@func DWORD  | GPI_Read | device write routine
//	@parm DWORD  | dwData   | value returned from GPI_Open call
//	@parm LPVOID | pBuf     | buffer to receive data
//	@parm DWORD  | dwLen    | maximum length to read
//	@rdesc	Returns 0 for end of file
DWORD
GPI_Read(
	DWORD	dwData,
	LPVOID	pBuf,
	DWORD	dwLen
	)
{
	return 0;
}

//	@func DWORD   | GPI_Write | device write routine
//	@parm DWORD   | dwData    | value returned from GPI_Open call
//	@parm LPCVOID | pBuf      | buffer containing data
//	@parm DWORD   | dwLen     | data length to write
//	@rdesc	Returns 0 for end of file
DWORD
GPI_Write(
	DWORD	dwData,
	LPCVOID	pBuf,
	DWORD	dwLen
	)
{
	return 0;
}

//	@func DWORD | GPI_Seek | device seek routine
//	@parm DWORD | dwData   | value returned from GPI_Open call
//	@parm long  | lPos     | position to seek to
//	@parm DWORD | dwType   | FILE_BEGIN, FILE_CURRENT, or FILE_END
//	@rdesc	Returns current position relative to start of file, or -1 on error
DWORD
GPI_Seek(
	DWORD	dwData,
	long	lPos,
	DWORD	dwType
	)
{
	return (DWORD)-1;
}

//	@func VOID | GPI_PowerUp | device powerup routine
//	@comm	Called power up device
VOID
GPI_PowerUp(
	DWORD	dwData
	)
{
}

//	@func VOID | GPI_PowerDown | device powerup routine
//	@comm	Called power down device
VOID
GPI_PowerDown(
	DWORD	dwData
	)
{
}

//	@func BOOL   | GPI_IOControl | Device IO control routine
//	@parm DWORD  | dwData        | value returned from GPI_Open call
//	@parm DWORD  | dwCode        | io control code to be performed
//	@parm PVOID  | pBufIn        | input data to the device
//	@parm DWORD  | dwLenIn       | number of bytes being passed in
//	@parm PVOID  | pBufOut       | output data from the device
//	@parm DWORD  | dwLenOut      | maximum number of bytes to receive from device
//	@parm PDWORD | pdwActualOut  | actual number of bytes received from device
//	@rdesc	Returns TRUE for success, FALSE for failure
BOOL
GPI_IOControl(
	DWORD	dwData,
	DWORD	dwCode,
	PVOID	pBufIn,
	DWORD	dwLenIn,
	PVOID	pBufOut,
	DWORD	dwLenOut,
	PDWORD	pdwActualOut
	)
{
	DWORD				dwRet;
	PGPIO_OPEN_INFO		pOpen = (PGPIO_OPEN_INFO)dwData;
	PGPIO_DRIVER_INFO	pGpio = pOpen -> pGPIOHandle;
	PGPIO_PORT_INFO		pPort = (PGPIO_PORT_INFO)pBufIn;