 /*!
yyyy 
 * \copyright  Copyright (C) Kontron AG 2010. All Rights Reserved.

 * 02may2011, edv: modified for VxWorks prototype
 
\project    KEAPI
\subproject
\file       keapi.h
\brief      KEAPI interface specification.
\author     Martin Kroul
\date       07.06.2010
\version    1.2
*****************************************************************************/
#ifndef KEAPI_H
#define KEAPI_H

#ifdef __cplusplus
extern "C" {
#endif

#include "keapi_types.h"

/*/////////////////////////////////////////////////////////////////////////////
// LIBRARY INITIALIZATION
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Initialization of Kontron EAPI.
\param[in]      pHostIp    IP address of a remote computer.If set
				to NULL, “localhost” or “127.0.0.1” then localhost is considered
				to be the target machine.
\param[out]     pBoardHandle Pointer to the handle of selected board.
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_ERROR
* - KEAPI_RET_INVALID_IP when IP address is not in a valid format
* - KEAPI_RET_RMT_CON_ERROR when the connection is not available
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiLibInitialize(
    KEAPI_PCHAR pHostIp,
    KEAPI_UINT32 port,
    KEAPI_PUINT32 pBoardHandle,
    KEAPI_UINT32 LogLevel,
    KEAPI_PCHAR pLogFile
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Uninitialization of Kontron EAPI on a selected board.
\param[in]      boardHandle Handle of the selected board
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiLibUnInitialize(
    KEAPI_UINT32  boardHandle
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information version of library
\param[in]      boardHandle Handle of selected board
\param[out]     pLibVersion Returned KEAPI_VERSION_DATA structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetLibVersion(
    KEAPI_UINT32  boardHandle,
    PKEAPI_VERSION_DATA pLibVersion
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Starts keapi server for remote connection
\param[in]      TCP port for client connections
\param[in]      set level for log file, zero value means that tracing to log file is switch off
\param[in]      set path for log file - can be NULL
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_ERROR in case of any error
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiLibStartServer(
	KEAPI_UINT32 port, 
	KEAPI_UINT32 LogLevel, 
	KEAPI_PCHAR pLogFile
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Stopps keapi server for remote connection
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_ERROR in case of any error
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiLibStopServer();

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information version of library
\param[in]      boardHandle Handle of selected board
\param[in]      timeout for communication with keapi server
\param[in]      attempts for communication with keapi server
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_ERROR in case of any error
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetTimeout(
    KEAPI_UINT32  boardHandle,
    KEAPI_UINT32  Timeout,
    KEAPI_UINT32  Attempts);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information version of library
\param[in]      Error number returned by any keapi function
\param[out]     StringError returns description corresponding to Error
\param[in]	    BufferLenght means size of allocated array for StringError
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetErrorString(
	KEAPI_UINT32	Error,
	KEAPI_PCHAR		StringError,
	KEAPI_UINT32	BufferLenght
	);


/*/////////////////////////////////////////////////////////////////////////////
// General information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides information about Kontron motherboard
\param[in]      boardHandle Handle of the selected board
\param[out]     pBoardInfo Returned board info structure BOARD_INFO
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBoardInfo (
	KEAPI_UINT32 boardHandle,
	PBOARD_INFO pBoardInfo
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about number of boot cycles within the board's lifetime
\param[in]      boardHandle Handle of selected board
\param[out]     pBootCount Number of boot cycles
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBootCounter (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pBootCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides time left since last boot
\param[in]      boardHandle Handle of the selected board
\param[out]     pSystemUpTime Pointer to a variable that receives system running time in seconds
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSystemUpTime (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pSystemUpTime
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides actual information whether computer case was opened or not
\param[in]      boardHandle      Handle of the selected board
\param[out]     pIntruderStatus  Pointer to a variable that receives actual intruder status
* - INTRUDER_STATUS_CASE CLOSED, 0
* - INTRUDER_STATUS_CASE OPENED , 1
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetIntruderStatus (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pIntruderStatus
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Resets the case intruder status
\param[in]      boardHandle     Handle of the selected board
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiResetIntruderStatus (
	KEAPI_UINT32 boardHandle
);

/*/////////////////////////////////////////////////////////////////////////////
// CPU information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides the CPU frequency of a given type
* - CPU minimal frequency: CPU_FREQUENCY_MIN, 0
* - CPU maximal frequency: CPU_FREQUENCY_MAX, 1
* - CPU current frequency: CPU_FREQUENCY_CURRENT, 2 
\param[in]      boardHandle     Handle of the selected board
\param[in]      freqType Type of frequency (minimal (CPU_FREQUENCY_MIN, 0), maximal (CPU_FREQUENCY_MAX, 1), current (CPU_FREQUENCY_CURRENT, 2)) 
\param[out]     frequency Frequency of the CPU, in kHz  
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetCpuFreq (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT8 freqType,
	KEAPI_PINT32 frequency
);

/*/////////////////////////////////////////////////////////////////////////// */
/*
\brief          Provides information about processors
\param[in]      boardHandle Handle of the selected board
\param[out]     pCpuInfo Returned CPU_INFO structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetCpuInfo (
	KEAPI_UINT32 boardHandle,
	PCPU_INFO pCpuInfo
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about the current CPU performance mode
* - high performance: CPU_PERFORMANCE_HIGH, 0
* - power save mode: CPU_PERFORMANCE_POWER_SAVE, 1
* - on demand mode: CPU_PERFORMANCE_ON_DEMAND, 2
* - conservative mode: CPU_PERFORMANCE_CONSERVATIVE, 3
\param[in]      boardHandle     Handle of the selected board
\param[out]     pPerformanceType Pointer to the type of current CPU performance. The type is given by a number (0 - 3)  
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetCpuPerformance (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT8 pPerformanceType,
        KEAPI_PINT8 pPerformancePercentage
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Allows you to set the type of the CPU performance
* - high performance: CPU_PERFORMANCE_HIGH, 0
* - power save mode: CPU_PERFORMANCE_POWER_SAVE, 1
* - on demand mode: CPU_PERFORMANCE_ON_DEMAND, 2
* - conservative mode: CPU_PERFORMANCE_CONSERVATIVE, 3
\param[in]      boardHandle     Handle of the selected board
\param[in]     performanceType Type of performance. The type is given by a number (0 - 3)  
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetCpuPerformance (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT8 performanceType,
	KEAPI_INT8 performancePercentage
);

/*/////////////////////////////////////////////////////////////////////////////
// Memory information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides information about physical memory
\param[in]      boardHandle Handle of selected board
\param[out]     pMemoryInfo Returned MEMORY_INFO structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetMemoryInfo (
	KEAPI_UINT32 boardHandle,
	PMEMORY_INFO pMemoryInfo
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides number of installed memory modules
\param[in]      boardHandle Handle of selected board
\param[out]     pMemoryModuleCount Number of installed memory modules
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetMemoryModuleCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pMemoryModuleCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about selected memory module
\param[in]      boardHandle Handle of the selected board
\param[in]      moduleNr Requested memory module's number. Numbers start with zero.
\param[out]     pMemoryModule Returned MEMORY_MODULE structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetMemoryModuleInfo (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT8 moduleNr,
	PMEMORY_MODULE pMemoryModule
);

/*/////////////////////////////////////////////////////////////////////////////
// HDD information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides number of installed disk drives
\param[in]      boardHandle     Handle of the selected board
\param[out]     pDiskDriveCount Number of installed disk drives
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetDiskDriveCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pDiskDriveCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides list of installed disk drives and their properties
\param[in]      boardHandle Handle of the selected board
\param[in]      diskDriveCount Number of disks
\param[out]     pDiskDrives Returned array of DISK_DRIVE structures.
                The array must be allocated as DiskDriveCount * sizeof(DISK_DRIVE),
                where DiskDriveCount is obtaind by calling KEApiGetDiskDriveCount.
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetDiskDriveList (
	KEAPI_UINT32 boardHandle,
	PDISK_DRIVE pDiskDrives,
	KEAPI_INT32 diskDriveCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides count of disk partitions
\param[in]      boardHandle     Handle of the selected board
\param[out]     pDiskPartitionCount Number of partitions for a specified hard drive
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetDiskDrivePartitionCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pDiskPartitionCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides list of disk partitions
\param[in]      boardHandle     Handle of the selected board
\param[in]      diskPartitionCount Number of partitions (size of elements in the pDiskPartitionData array)
\param[out]     pDiskPartitionData Array of DISK_PARTITION structures
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetDiskDrivePartitionList (
	KEAPI_UINT32 boardHandle,
	PDISK_PARTITION pDiskPartitionData,
	KEAPI_UINT32 diskPartitionCount
);

/*/////////////////////////////////////////////////////////////////////////////
// Battery information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides number of installed batteries
\param[in]      boardHandle Handle of the selected board
\param[out]     pBatteryCount Number of installed batteries
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBatteryCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pBatteryCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about battery
\param[in]      boardHandle Handle of the selected board
\param[in]      batteryNr Requested battery's number. Numbers start with zero.
\param[out]     pBatteryInfo Returned BATTERY_INFO structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBatteryInfo (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT8 batteryNr,
	PBATTERY_INFO pBatteryInfo
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about selected battery
\param[in]      boardHandle  Handle of the selected board
\param[in]      batteryNr    Requested battery's number. Numbers start with zero
\param[out]     pBatteryState  Pointer to a BATTERY_STATE structure
* - POWER_STATE_CHARGING, 0
* - POWER_STATE_CHARGED, 1
* - POWER_STATE_DISCHARGING, 2
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBatteryState (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 batteryNr,
	PBATTERY_STATE pBatteryState
);

/*/////////////////////////////////////////////////////////////////////////////
// Temperature sensors information
///////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides number of temperature sensors
\param[in]      boardHandle     Handle of the selected board
\param[out]     pTempSensorCount Pointer to number of installed temperature sensors
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetTempSensorCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pTempSensorCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about temperature sensors (their name and current value), stored in the TEMP_SENSOR structure
\param[in]      boardHandle     Handle of the selected board
\param[in]      tempSensorCount Number of temperature sensors
\param[out]     pTempSensors Pointer to the temperature sensors structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetTempSensorList (
	KEAPI_UINT32 boardHandle,
	PTEMP_SENSOR pTempSensors,
	KEAPI_INT32 tempSensorCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Derives information about current value of a temperature sensor with a given ID
\param[in]      boardHandle     Handle of the selected board
\param[in]      tempSensorNr Number (index) of a temperature sensor. Numbers start with 0
\param[out]     pTempSensorValue Pointer to the value of a given temperature sensor
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetTempSensorValue (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 tempSensorNr,
	KEAPI_PINT32 pTempSensorValue
);

/*/////////////////////////////////////////////////////////////////////////// */
/*
\brief          Provides information about actual temperature of the selected CPU
\param[in]      boardHandle Handle of the selected board
\param[in]      cpuNr       Selected CPU number. CPU numbers start with zero
\param[out]     pCpuTemp    Pointer to a variable that receives selected CPU’s core temperature in Kelvins
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetCpuTemp (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 cpuNr,
	KEAPI_PINT32 pCpuTemp
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about actual chipset temperature
\param[in]      boardHandle  Handle of the selected board
\param[out]     pChipsetTemp Pointer to a variable that receives chipset temperature in Kelvins
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetChipsetTemp (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pChipsetTemp
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about actual system temperature
\param[in]      boardHandle  Handle of selected board
\param[out]     pSystemTemp Pointer to a variable that receives system temperature in Kelvins
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetSystemTemp (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pSystemTemp
);

/*/////////////////////////////////////////////////////////////////////////////
// Voltage sensors information
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides number of voltage sensors
\param[in]      boardHandle     Handle of the selected board
\param[out]     pVoltageSensorCount Pointer to the voltage sensors count
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetVoltageSensorCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pVoltageSensorCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about voltage sensors in the structure VOLTAGE_SENSOR
\param[in]      boardHandle     Handle of the selected board
\param[in]      voltageSensorCount Number of sensors, obtained from the function KEApiGetVoltageSensorCount
\param[out]     pVoltageSensors Pointer to the voltage sensors structure VOLTAGE_SENSOR
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetVoltageSensorList (
	KEAPI_UINT32 boardHandle,
	PVOLTAGE_SENSOR pVoltageSensors,
	KEAPI_INT32 voltageSensorCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides current voltage value of a selected voltage sensor
\param[in]      boardHandle     Handle of the selected board
\param[in]      voltageSensorNr Number (index) of a voltage sensor you are interested in. Numbers start with 0 
\param[out]     pVoltageSensorValue Pointer to the value of the selected sensor, in millivolts 
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetVoltageSensorValue (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 voltageSensorNr,
	KEAPI_PINT32 pVoltageSensorValue
);

/*/////////////////////////////////////////////////////////////////////////////
// Fan control
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides number of fans
\param[in]      boardHandle Handle of the selected board
\param[out]     pFanCount Pointer to number of fans
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetFanCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pFanCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about fans
\param[in]      boardHandle Handle of the selected board
\param[in]      fanCount Number of fans, which can be obtained from the KEApiGetFanCount function
\param[out]     pFans Pointer to PFAN structure
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetFanList (
	KEAPI_UINT32 boardHandle,
	PFAN pFans,
	KEAPI_INT32 fanCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about fan speed
\param[in]      boardHandle Handle of the selected board
\param[in]      fanNr Number (index) of a fan you are interested in. Fan numbers start with 0
\param[out]     pwm Returned fan speed in pwm. Can be set to NULL if not wanted.
\param[out]     rpm Returned fan speed in rpm. Can be set to NULL if not wanted.
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetFanSpeed (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 fanNr,
	KEAPI_PUINT8 pwm,
	KEAPI_PINT32 rpm
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about fan mode.
*  - Maximal speed: FAN_METHOD_MAX_SPEED, 0
*  - Manual control: FAN_METHOD_MANUAL, 1
*  - Thermal cruise: FAN_METHOD_THERMAL_CRUISE, 2
\param[in]      boardHandle Handle of the selected board
\param[in]      fanNr Number (index) of a fan you are interested in. Fan numbers start with 0.
\param[out]     fanMode Mode in which the fan currently is (max speed, manual control, thermal cruise). 
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetFanMode (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 fanNr,
	KEAPI_PUINT8 fanMode
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Sets the fan into manual control mode 
\param[in]      boardHandle Handle of the selected board
\param[in]      fanNr Number (index) of a fan you are interested in. Fan numbers start with 0.
\param[in]      targetPwm Desired speed of the fan, in pwm, must be in a range of 0 - 255 (full speed)
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetFanModeManual (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 fanNr,
	KEAPI_UINT8 targetPwm
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Sets the fan into thermal cruise mode 
\param[in]      boardHandle Handle of the selected board
\param[in]      fanNr Number (index) of a fan you are interested in. Fan numbers start with 0.
\param[in]      targetTemp What temperature should not be exceeded, in millidegrees 
\param[in]      toleranceTemp Tolerance of the target temperature. The controlled temperature should fluctuate around the target temperature within given tolerance. I.e. If the target temperature is 30 degrees Celsius, and the toleranece is set to 2 degrees Celsius, then the temperature is controlled in the range of 28 - 32 degrees Celsius. 30 degrees can be therefore exceeded, but 32 degrees 
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetFanModeThermalCruise (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 fanNr,
	KEAPI_UINT32 targetTemp,
	KEAPI_UINT32 toleranceTemp
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about CPU fan speed (revolutions per minute)
\param[in]      boardHandle  Handle of the selected board
\param[out]     pCpuFanRpm   Pointer to a variable that receives cpu fan rpm
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetCpuFanSpeed (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pCpuFanRpm
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Sets speed of CPU fan using Pulse Width Modulation
\param[in]      boardHandle      Handle of the selected board
\param[in]      cpuFanSpeedPwm Required CPU fan speed pwm 0 - 255 (max. speed)
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetCpuFanSpeed (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT8 cpuFanSpeedPwm
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about system fan speed (revolutions per minute)
\param[in]      boardHandle    Handle of the selected board
\param[out]     pSystemFanRpm  Pointer to a variable that receives system fan rpm
\return
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetSystemFanSpeed (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pSystemFanRpm
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Sets speed of system fan using Pulse Width Modulation.
\param[in]      boardHandle     Handle of selected board
\param[in]      systemFanSpeedPwm  Required system fan speed pwm 0 - 255 (max. speed)
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetSystemFanSpeed (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT8 systemFanSpeedPwm
);

/*/////////////////////////////////////////////////////////////////////////////
// Display
///////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides number of installed displays
\param[in]      boardHandle  Handle of the selected board
\param[out]     pDisplayCount Number of installed displays
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetDisplayCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pDisplayCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about current backlight intensity
\param[in]      boardHandle  Handle of the selected board
\param[in]      displayNr    Requested display's number. Numbers start with zero
\param[out]     pBacklight   Pointer to variable that receives actual brightness intensity in percentage
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetBacklightValue (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 displayNr,
	KEAPI_PINT32 pBacklight
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Sets backlight intensity of LVDS display
\param[in]      boardHandle  Handle of the selected board
\param[in]      displayNr    Requested display's number. Numbers start with zero
\param[out]     backlight    Required backlight intensity in percentage (0 - 100)
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetBacklightValue (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 displayNr,
	KEAPI_INT32 backlight
);

/*/////////////////////////////////////////////////////////////////////////////
// Network and PCI devices info
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides a number of installed network devices
\param[in]      boardHandle Handle of the selected board
\param[out]     pNetworkDeviceCount Number of installed network devices
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetNetworkDeviceCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pNetworkDeviceCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides a list of installed network devices information
\param[in]      boardHandle     Handle of the selected board
\param[in]      networkDeviceCount Number of network devices
\param[out]     pNetworkDevices Pointer to array of NETWORK_DEVICE structures.
                The array must be allocated as NetworkDeviceCount * sizeof(NETWORK_DEVICE),
                where NetworkDeviceCount is obtaind by calling KEApiGetNetworkDeviceCount.
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetNetworkDeviceList (
	KEAPI_UINT32 boardHandle,
	PNETWORK_DEVICE pNetworkDevices,
	KEAPI_INT32 networkDeviceCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides a number of installed PCI devices
\param[in]      boardHandle Handle of the selected board
\param[out]     pPciDeviceCount Number of installed PCI devices
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetPciDeviceCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PINT32 pPciDeviceCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides a list of PCI devices
\param[in]      boardHandle Handle of the selected board
\param[in]      pciDeviceCount Number of installed PCI devices
\param[out]     pPciDevices Returned array of PCI_DEVICE structures
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetPciDeviceList (
	KEAPI_UINT32 boardHandle,
	PPCI_DEVICE pPciDevices,
	KEAPI_INT32 pciDeviceCount
);

/*/////////////////////////////////////////////////////////////////////////////
// Storage area	
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Provides information about EEPROM storage areas count
\param[in]      boardHandle       Handle of the selected board
\param[out]     pStorageCount Number of available storage areas
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetStorageCount(
    KEAPI_UINT32  boardHandle,
    KEAPI_PINT32 pStorageCount
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Provides information about EEPROM storage area sizes 
\param[in]      boardHandle  Handle of the selected board
\param[in]      storageNr Number of the storage area. Number of storage areas can be obtained from the KEApiGetStorageCount function
\param[out]     pStorageSize  Pointer to array of sizes of available storage areas. Length of the array is StorageCount * sizeof(KEAPI_INT32)
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetStorageSize (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 storageNr,
	KEAPI_PINT32 pStorageSize
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Reads block of bytes from selected EEPROM
\param[in]      boardHandle  Handle of the selected board
\param[in]      storageNr    EEPROM storage number. Number of storage areas can be obtained from KEApiGetStorageCount function
\param[in]      offset       Start address offset
\param[out]     pData      Pointer to buffer that receives data
\param[in]      dataLength    Number of bytes to read
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiStorageRead (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 storageNr,
	KEAPI_INT32 offset,
	KEAPI_PUINT8 pData,
	KEAPI_INT32 dataLength
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Writes block of bytes to selected EEPROM
\param[in]      boardHandle  Handle of selected board
\param[in]      storageNr    EEPROM storage number. Number of storage areas can be obtained FROM KEApiGetStorageCount function
\param[in]      offset       Start address offset
\param[in]      pData      Pointer to buffer that contains data to write to EEPROM
\param[in]      dataLength    Number of bytes to write
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiStorageWrite (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 storageNr,
	KEAPI_INT32 offset,
	KEAPI_PUINT8 pData,
	KEAPI_INT32 dataLength
);

/*/////////////////////////////////////////////////////////////////////////////
// I2C
///////////////////////////////////////////////////////////////////////////// */

KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetI2cBusCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PUCHAR pI2cBusCount
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiI2cWrite(
        KEAPI_UINT32    boardHandle,
        KEAPI_UCHAR     i2cNr,
        KEAPI_UCHAR     i2cAddress,
        KEAPI_UCHAR     memoryAddress,
        KEAPI_PUCHAR    pData,
        KEAPI_UINT32    dataLength
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiI2cRead (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR i2cNr,
	KEAPI_UCHAR i2cAddress,
	KEAPI_UCHAR memoryAddress,
	KEAPI_BOOL memoryAddressUsed,
	KEAPI_PUCHAR pData,
	KEAPI_PUINT32 pDataLength
); 

/*/////////////////////////////////////////////////////////////////////////////
// SMBus
///////////////////////////////////////////////////////////////////////////// */

KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetSmbusCount (
	KEAPI_UINT32 boardHandle,
	KEAPI_PUCHAR pSmbusCount
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusQuickCommand (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR operation
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusSendByte(
        KEAPI_UINT32    boardHandle,
        KEAPI_UCHAR     smbusNr,
        KEAPI_UCHAR     smbusAddress,
        KEAPI_UCHAR     byte
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusReceiveByte (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_PUCHAR pByte
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusWriteByte (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_UCHAR byte
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusReadByte (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_PUCHAR pByte
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusWriteWord (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_UINT16 word
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusReadWord (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_PUINT16 pWord
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusWriteBlock (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_PUCHAR pData,
	KEAPI_UCHAR dataLength
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSmbusReadBlock (
	KEAPI_UINT32 boardHandle,
	KEAPI_UCHAR smbusNr,
	KEAPI_UCHAR smbusAddress,
	KEAPI_UCHAR command,
	KEAPI_PUCHAR pData,
	KEAPI_PUCHAR pDataLength
); 

/*/////////////////////////////////////////////////////////////////////////////
// GPIO
///////////////////////////////////////////////////////////////////////////// */

KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioGetCount(
        KEAPI_UINT32    boardHandle,
        KEAPI_PUINT32   pGpioCount
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioGetDirectionCaps (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 gpioNr,
	KEAPI_PBOOL pIsInput,
	KEAPI_PBOOL pIsOutput
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioGetDirection (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 gpioNr,
	KEAPI_PUCHAR pDirection
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioSetDirection (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 gpioNr,
	KEAPI_UCHAR  direction
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioGetLevel (
	KEAPI_UINT32 boardHandle,
	KEAPI_UINT32 gpioNr,
	KEAPI_PUCHAR pLevel
); 

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGpioSetLevel(
        KEAPI_UINT32    boardHandle,
        KEAPI_UINT32    gpioNr,
        KEAPI_UCHAR     level
);

/*/////////////////////////////////////////////////////////////////////////////
// Watchdog
///////////////////////////////////////////////////////////////////////////// */

/*!
\brief          Enables the watchdog
\param[in]      boardHandle  Handle of the selected board
\param[in]      timeout  Watchdog timeout interval in milliseconds
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiWatchdogEnable (
	KEAPI_UINT32 boardHandle,
	KEAPI_INT32 timeout
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Disables the watchdog
\param[in]      boardHandle  Handle of the selected board
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiWatchdogDisable(
    KEAPI_UINT32  boardHandle
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Triggers the WatchDog timer
\param[in]      boardHandle  Handle of the selected board
\return         
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiWatchdogTrigger(
    KEAPI_UINT32  boardHandle
);

/*/////////////////////////////////////////////////////////////////////////////
// System state
///////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Uses Intel AMT to get information about power state of a remote board
*  - Turned on:  SYSTEM_STATE_TURN_ON, 0
*  - Turned off: SYSTEM_STATE_TURN_OFF, 1
*  - Hibernated: SYSTEM_STATE_HIBERNATE, 2
\param[in]      pHostIp IP address of the remote board
\param[in]      pUser User name AMT
\param[in]      pPassword Password AMT
\param[out]     pSystemState Pointer to variable that will receive remote board's power state
\return
* - KEAPI_RET_SUCCESS on success
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiGetSystemStateAmt(
    KEAPI_PCHAR pHostIp,
    KEAPI_PCHAR pUser,
    KEAPI_PCHAR pPassword,
    KEAPI_PINT32 pSystemState
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Uses Intel AMT to set power state of a remote board
*  - Turn on:   SYSTEM_STATE_TURN_ON,   0
*  - Turn off:  SYSTEM_STATE_TURN_OFF,  1
*  - Hibernate: SYSTEM_STATE_HIBERNATE, 2
*  - Restart:   SYSTEM_STATE_RESTART,   3
\param[in]      pHostIp IP address of the remote board
\param[in]      pUser User name AMT
\param[in]      pPassword Password AMT
\param[in]      systemState Desired system state
\return
* - KEAPI_RET_SUCCESS on success
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetSystemStateAmt(
    KEAPI_PCHAR pHostIp,
    KEAPI_PCHAR pUser,
    KEAPI_PCHAR pPassword,
    KEAPI_INT32 systemState
);

/*/////////////////////////////////////////////////////////////////////////// */
/*!
\brief          Uses operating system call to set power state of a remote board
*  - Turn off:  SYSTEM_STATE_TURN_OFF,  1
*  - Hibernate: SYSTEM_STATE_HIBERNATE, 2
*  - Restart:   SYSTEM_STATE_RESTART,   3
\param[in]      boardHandle  Handle of the selected board
\param[in]      systemState Desired system state
\return
* - KEAPI_RET_SUCCESS on success
* - KEAPI_RET_NOT_INITIALIZED when library is not initialized
*/
KEAPI_CALLTYPE KEAPI_UINT32 KEApiSetSystemState(
    KEAPI_UINT32 boardHandle,
    KEAPI_INT32 systemState
);

/*/////////////////////////////////////////////////////////////////////////// */
KEAPI_CALLTYPE KEAPI_UINT32 KEApiTest( 
		KEAPI_UINT32  boardHandle, 
		KEAPI_PUINT32  ui32_test1, 
		KEAPI_PUINT8   ui8_test1, 
		KEAPI_PUINT32  ui32_test2, 
		KEAPI_PUINT8   ui8_test2,
		KEAPI_PFLOAT   f32_test1,
		KEAPI_PUINT8   ui8_test3
		);

#ifdef __cplusplus
} // #ifdef __cplusplus
#endif

#endif  /* KEAPI_H */
/**********************************************************************
  Copyright (C) Kontron AG 2010. All Rights Reserved.
 **********************************************************************/
