File linux-2.6.34-pch-ieee1588.patch of Package kernel-n900-2.6.33.3-11.2.armv7l

Overview Repositories Revisions Requests Users Attributes Meta

File linux-2.6.34-pch-ieee1588.patch of Package kernel-n900-2.6.33.3-11.2.armv7l (Revision 93aa6ac4b5db14adaa32a8a230919769)

Currently displaying revision 93aa6ac4b5db14adaa32a8a230919769 , Show latest

From: Masayuki Ohtake <masa-korg@dsn.okisemi.com>
Subject: OKI Semiconductor PCH IEEE1588 driver

This driver implements IEEE1588 controls for PCH.

Signed-off-by: Masayuki Ohtake <masa-korg@dsn.okisemi.com>
Acked-by: Wang Qi <qi.wang@intel.com>

---
 drivers/char/Kconfig                         |    7 ++
 drivers/char/Makefile                        |    2 
 drivers/char/pch_ieee1588/Makefile           |    10
 drivers/char/pch_ieee1588/pch_1588_hal.c     |    4040
 drivers/char/pch_ieee1588/pch_1588_hal.h     |    885
 drivers/char/pch_ieee1588/pch_1588_main.c    |    1192
 drivers/char/pch_ieee1588/pch_1588_main.h    |    702
 drivers/char/pch_ieee1588/pch_1588_pci.c     |    700
 drivers/char/pch_ieee1588/pch_1588_pci.h     |    122
 drivers/char/pch_ieee1588/pch_common.h       |    146
 drivers/char/pch_ieee1588/pch_debug.h        |    60
+++++++++++++++++++++++++++++++ 11 files changed, zz insertions(+)
diff -urN linux-2.6.33-rc3/drivers/char/Kconfig topcliff-2.6.33-rc3/drivers/char/Kconfig
--- linux-2.6.33-rc3/drivers/char/Kconfig	2010-01-06 09:02:46.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/Kconfig	2010-03-09 10:14:52.000000000 +0900
@@ -4,6 +4,13 @@
 
 menu "Character devices"
 
+config PCH_IEEE1588
+	tristate "PCH IEEE1588"
+	depends on PCI
+	help
+	  If you say yes to this option, support will be included for the
+	  PCH IEEE1588 Host controller.
+
 config VT
 	bool "Virtual terminal" if EMBEDDED
 	depends on !S390
diff -urN linux-2.6.33-rc3/drivers/char/Makefile topcliff-2.6.33-rc3/drivers/char/Makefile
--- linux-2.6.33-rc3/drivers/char/Makefile	2010-01-06 09:02:46.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/Makefile	2010-03-05 22:57:39.000000000 +0900
@@ -111,6 +111,8 @@
 obj-$(CONFIG_JS_RTC)		+= js-rtc.o
 js-rtc-y = rtc.o
 
+obj-$(CONFIG_PCH_IEEE1588)		+= pch_ieee1588/
+
 # Files generated that shall be removed upon make clean
 clean-files := consolemap_deftbl.c defkeymap.c
 
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/Makefile topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/Makefile
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/Makefile	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/Makefile	2010-03-10 04:52:54.000000000 +0900
@@ -0,0 +1,10 @@
+ifeq ($(CONFIG_IEEE1588_DEBUG_CORE),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
+
+obj-$(CONFIG_PCH_IEEE1588) += pch_ieee1588.o
+
+#for A0_A1_SAMPLE LSI board
+EXTRA_CFLAGS+=-DIOH_IEEE1588_A0_A1_SAMPLE_BUG
+
+pch_ieee1588-objs := pch_1588_main.o pch_1588_pci.o pch_1588_hal.o
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.c topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.c
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.c	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.c	2010-03-09 10:34:22.000000000 +0900
@@ -0,0 +1,4040 @@
+ /*!
+  * @file ioh_1588_hal.c
+  * @brief
+  * This file has the definitions for HALLAyer APIs.
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intel EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ *
+ */
+
+#include <linux/io.h>
+#include "pch_common.h"
+#include "pch_debug.h"
+#include <linux/module.h>
+#include "pch_1588_hal.h"
+
+/*
+ * HAL API definitions for the IEEE 1588 module
+ */
+
+/*! @ingroup	IEEE1588
+ *  @def	INLINE
+ *  @brief	The macro used instead of the keyword __inline.
+*/
+#define INLINE inline
+
+/*Register read/write macros*/
+#define IOH_REG_32_READ(regAddr, varRef) (*(varRef) = IOH_READ32(regAddr))
+#define IOH_REG_32_WRITE(regAddr, varValue) IOH_WRITE32(varValue, regAddr)
+#define IOH_BIT_SET_CHECK(regAddr, bitMask) \
+    ((IOH_READ32(regAddr)  & (bitMask)) == (bitMask))
+
+#ifdef IOH_IEEE1588_A1_SAMPLE_BUG
+/*global variable to store tick rate*/
+static unsigned long gTickRateApp;
+#endif
+
+/* function prototypes */
+/* TS_Control register access routines */
+static INLINE void ioh_1588_pps_imask_set(void);
+static INLINE void ioh_1588_amms_imask_set(void);
+static INLINE void ioh_1588_asms_imask_set(void);
+static INLINE void ioh_1588_ttm_imask_set(void);
+static INLINE void ioh_1588_pps_imask_clear(void);
+static INLINE void ioh_1588_amms_imask_clear(void);
+static INLINE void ioh_1588_asms_imask_clear(void);
+static INLINE void ioh_1588_ttm_imask_clear(void);
+static INLINE unsigned long ioh_1588_pps_imask_get(void);
+static INLINE unsigned long ioh_1588_amms_imask_get(void);
+static INLINE unsigned long ioh_1588_asms_imask_get(void);
+static INLINE unsigned long ioh_1588_ttm_imask_get(void);
+static INLINE void ioh_1588_block_reset(void);
+
+/* TS_Event register access routines */
+static INLINE unsigned long ioh_1588_pps_evt_get(void);
+static INLINE unsigned long ioh_1588_amms_evt_get(void);
+static INLINE unsigned long ioh_1588_asms_evt_get(void);
+static INLINE unsigned long ioh_1588_ttm_evt_get(void);
+static INLINE void ioh_1588_pps_evt_clear(void);
+static INLINE void ioh_1588_amms_evt_clear(void);
+static INLINE void ioh_1588_asms_evt_clear(void);
+static INLINE void ioh_1588_ttm_evt_clear(void);
+
+/* TS_Addend register access routines - Frequency Scaling Value */
+static INLINE void ioh_1588_addend_set(unsigned long fsv);
+static INLINE void ioh_1588_addend_get(unsigned long *fsv);
+
+/* TS_PPS_Compare register access routines */
+static INLINE void ioh_1588_pps_set(unsigned long fsv);
+static INLINE void ioh_1588_pps_get(unsigned long *fsv);
+/* TS_SYSTimeLo, Hi registers access routines */
+static INLINE void ioh_1588_sys_snap_set(unsigned long sys_time_low,
+					 unsigned long sys_time_high);
+static INLINE void ioh_1588_sys_snap_get(unsigned long *sys_time_low,
+					 unsigned long *sys_time_high);
+/* TS_TrgtTimeLo, Hi registers access routines */
+static INLINE void ioh_1588_tgt_snap_set(unsigned long tgt_time_low,
+					 unsigned long tgt_time_high);
+static INLINE void ioh_1588_tgt_snap_get(unsigned long *tgt_time_low,
+					 unsigned long *tgt_time_high);
+/* TS_ASMSLo, Hi registers access routines */
+static INLINE void ioh_1588_aux_slave_snap_get(unsigned long *asms_low,
+					       unsigned long *asms_high);
+/* TS_AMMSLo, Hi registers access routines */
+static INLINE void ioh_1588_aux_master_snap_get(unsigned long *amms_low,
+						unsigned long *amms_high);
+
+/* TS_Ch_Control register access routines */
+static INLINE void ioh_1588_master_mode_set(unsigned long master_mode);
+static INLINE unsigned long ioh_1588_master_mode_get(void);
+static INLINE void ioh_1588_timestamp_all_set(unsigned long allMsg);
+static INLINE unsigned long ioh_1588_timestamp_all_get(void);
+static INLINE void ioh_1588_op_mode_set(unsigned long mode);
+static INLINE unsigned long ioh_1588_op_mode_get(void);
+static INLINE void ioh_1588_version_set(unsigned long versionVal);
+static INLINE unsigned long ioh_1588_version_get(void);
+
+/* TS_Ch_Event register access routines */
+static INLINE unsigned long ioh_1588_rx_snap_evt(void);
+static INLINE unsigned long ioh_1588_tx_snap_evt(void);
+static INLINE void ioh_1588_rx_snap_evt_clear(void);
+static INLINE void ioh_1588_tx_snap_evt_clear(void);
+/* TS_TxSnapLo, Hi registers access routines */
+static INLINE void ioh_1588_tx_snap_get(unsigned long *txs_low,
+					unsigned long *txs_high);
+/* TS_RxSnapLo, Hi registers access routines */
+static INLINE void ioh_1588_rx_snap_get(unsigned long *rxs_low,
+					unsigned long *rxs_high);
+/* TS_srcUUIDLo, Hi registers access routines */
+static INLINE void ioh_1588_uuid_seqid_get(unsigned long *uuid_low,
+					   unsigned long *uuid_high,
+					   unsigned int *seq_id);
+
+static INLINE unsigned long ioh_1588_can_snap_valid(void);
+static INLINE unsigned long ioh_1588_can_snap_ovr(void);
+static INLINE void ioh_1588_can_snap_valid_clear(void);
+static INLINE void ioh_1588_can_snap_ovr_clear(void);
+static INLINE void ioh_1588_can_snap_get(unsigned long *rxs_low,
+					 unsigned long *rxs_high);
+
+static INLINE void ioh_1588_eth_enable_set(void);
+static INLINE void ioh_1588_eth_enable_clear(void);
+static INLINE unsigned long ioh_1588_eth_enable_get(void);
+static INLINE void ioh_1588_can_enable_set(void);
+static INLINE void ioh_1588_can_enable_clear(void);
+static INLINE unsigned long ioh_1588_can_enable_get(void);
+static INLINE void ioh_1588_station_set(unsigned long station,
+					unsigned long value);
+static INLINE void ioh_1588_station_get(unsigned long station,
+					unsigned long *value);
+
+/* Masks to extract High and Low SHORTs from unsigned long values */
+#define IOH_1588_MSB_SHORT_MASK  (0xFFFF0000)
+#define IOH_1588_LSB_SHORT_MASK  (0x0000FFFF)
+
+/* Location of SeqID in the register */
+#define IOH_1588_SID_LOC         (16)
+
+/* Variable declarations */
+
+/**
+ * Client registered callback routines for
+ * a) the target time reached or exceeded interrupt notification
+ * b) the auxiliary time stamps availability interrupt notification
+ * c) the pulse per second match interrupt notification
+ */
+static ioh1588TargetTimeCallback ioh_tt_cbptr =
+    (ioh1588TargetTimeCallback) NULL;
+static ioh1588AuxTimeCallback ioh_am_cbptr = (ioh1588AuxTimeCallback) NULL;
+static ioh1588AuxTimeCallback ioh_as_cbptr = (ioh1588AuxTimeCallback) NULL;
+static ioh1588PulsePerSecondCallback ioh_pps_cbptr =
+    (ioh1588PulsePerSecondCallback) NULL;
+
+/* The transmit and receive timestamp statistics */
+static struct ioh1588Stats ioh_1588_stats = { 0, 0 };
+
+/* To save the state of all registers of the module */
+static struct ioh_1588_regs_set ioh_1588_regs;
+
+/* IO mapped virtual address for the 1588 registers */
+static unsigned long ioh_1588_base;
+
+/* local functions definitions.  */
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_pps_imask_set(void)
+ *  @brief	Enable PPS Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+
+static INLINE void ioh_1588_pps_imask_set(void)
+{
+	/* SET the ppsm bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_PPSM_MASK);
+}
+
+/** @ingroup	 IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_amms_imask_set(void)
+ *  @brief	Enable Auxiliary Master Mode Snapshot Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_amms_imask_set(void)
+{
+	/* SET the amms bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_AMMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_asms_imask_set(void)
+ *  @brief	Enable Auxiliary Slave Mode Snapshot Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_asms_imask_set(void)
+{
+	/* SET the asms bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_ASMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_ttm_imask_set(void)
+ *  @brief	Enable Target Time Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_ttm_imask_set(void)
+{
+	/* SET the ttm bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_TTM_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_pps_imask_get(void)
+ *  @brief	Get PPS Interrupt Mask value
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_pps_imask_get(void)
+{
+	/* Is the ppsm bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSC_OFFSET,
+				 IOH_1588_TSC_PPSM_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_amms_imask_get(void)
+ *  @brief 	Get Auxiliary Master Mode Snapshot Interrupt Mask value
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_amms_imask_get(void)
+{
+	/* Is the amms bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSC_OFFSET,
+				 IOH_1588_TSC_AMMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+    @fn		static INLINE unsigned long ioh_1588_asms_imask_get(void)
+    @brief	Get Auxiliary Slave Mode Snapshot Interrupt  Mask value
+    @param	None
+    @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_asms_imask_get(void)
+{
+	/* Is the asms bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSC_OFFSET,
+				 IOH_1588_TSC_ASMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_ttm_imask_get(void)
+ *  @brief	Get Target Time Interrupt Mask value
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_ttm_imask_get(void)
+{
+	/* Is the ttm bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSC_OFFSET,
+				 IOH_1588_TSC_TTM_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+    @fn		static INLINE void ioh_1588_pps_imask_clear(void)
+    @brief	Disable PPS Interrupt
+    @param	None
+    @retval	None
+*/
+static INLINE void ioh_1588_pps_imask_clear(void)
+{
+	/* CLEAR the ppsm bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_PPSM_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_amms_imask_clear(void)
+ *  @brief	Disable Auxiliary Master Mode Snapshot Interrupt.
+ *  @param	None.
+ *  @retval	None
+*/
+static INLINE void ioh_1588_amms_imask_clear(void)
+{
+	/* CLEAR the amms bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_AMMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_asms_imask_clear(void)
+ *  @brief	Disable Auxiliary Slave Mode Snapshot Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_asms_imask_clear(void)
+{
+	/* CLEAR the asms bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_ASMS_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_ttm_imask_clear(void)
+ *  @brief	Disable Target Time Interrupt
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_ttm_imask_clear(void)
+{
+	/* CLEAR the ttm bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_TTM_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_block_reset(void)
+ *  @brief	Reset Hardware Assist block
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_block_reset(void)
+{
+	/* SET the rst bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_RESET);
+	/* CLEAR the rst bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_TSC_OFFSET,
+			 IOH_1588_TSC_RESET);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_pps_evt_get(void)
+ *  @brief	Poll for PPS event
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_pps_evt_get(void)
+{
+	/* Check for PPS event */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSE_OFFSET,
+				 IOH_1588_TSE_PPS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_amms_evt_get(void)
+ *  @brief	Poll for Auxiliary Master Mode Snapshot Captured event
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_amms_evt_get(void)
+{
+	/* Check for AMMS event */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSE_OFFSET,
+				 IOH_1588_TSE_SNM);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_asms_evt_get(void)
+ *  @brief	Poll for Auxiliary Slave Mode Snapshot Captured event
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_asms_evt_get(void)
+{
+	/* Check ASMS event */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSE_OFFSET,
+				 IOH_1588_TSE_SNS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_ttm_evt_get(void)
+ *  @brief 	Poll for Target Time Reached event
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_ttm_evt_get(void)
+{
+	/* Check target time pending event */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_TSE_OFFSET,
+				 IOH_1588_TSE_TTIPEND);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_pps_evt_clear(void)
+ *  @brief	Clear PPS event
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_pps_evt_clear(void)
+{
+	/* clear the pps bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSE_OFFSET, IOH_1588_TSE_PPS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_amms_evt_clear(void)
+ *  @brief	Clear Auxiliary Master Mode Snapshot Captured event
+ *  @param	None.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_amms_evt_clear(void)
+{
+	/* clear the snm bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSE_OFFSET, IOH_1588_TSE_SNM);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_asms_evt_clear(void)
+ *  @brief	Clear Auxiliary Slave Mode Snapshot Captured event
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_asms_evt_clear(void)
+{
+	/* clear the sns bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSE_OFFSET, IOH_1588_TSE_SNS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_ttm_evt_clear(void)
+ *  @brief	Clear Target Time Reached event
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_ttm_evt_clear(void)
+{
+	/* CLEAR the ttipend bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_TSE_OFFSET,
+			 IOH_1588_TSE_TTIPEND);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_sys_snap_set(
+ *			unsigned long sys_time_low, unsigned long sys_time_high)
+ *  @brief	Set System Time value
+ *  @param	sys_time_low 	[IN]	The system time low.
+ *  @param	sys_time_high	{In}	The system time high.
+ *  @retval	None
+*/
+static INLINE void
+ioh_1588_sys_snap_set(unsigned long sys_time_low, unsigned long sys_time_high)
+{
+	/* Update the System Time Low Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_STL_OFFSET, sys_time_low);
+
+	/* Update the System Time High Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_STH_OFFSET, sys_time_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE voidioh_1588_sys_snap_get(
+ *		unsigned long *sys_time_low, unsigned long *sys_time_high)
+ *  @brief	Get System Time Low value
+ *  @param	sys_time_low	[OUT]	The system time low.
+ *  @param	sys_time_high	[OUT]	The system time high.
+ *  @retval	None
+*/
+static INLINE void
+ioh_1588_sys_snap_get(unsigned long *sys_time_low, unsigned long *sys_time_high)
+{
+	/* Get the System Time Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_STL_OFFSET, sys_time_low);
+
+	/* Get the System Time High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_STH_OFFSET, sys_time_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_tgt_snap_set (
+ *			unsigned long tgt_time_low, unsigned long tgt_time_high)
+ *  @brief 	Set Target Time value
+ *  @param	tgt_time_low	[IN]	The target time low.
+ *  @param	tgt_time_high	[IN]	The target time high.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_tgt_snap_set(unsigned long tgt_time_low, unsigned long tgt_time_high)
+{
+	/* Update the Target Time Low Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_TTL_OFFSET, tgt_time_low);
+
+	/* Update the Target Time High Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_TTH_OFFSET, tgt_time_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_tgt_snap_get(
+ *		unsigned long *tgt_time_low, unsigned long *tgt_time_high)
+ *  @brief	Get Target Time value
+ *  @param	tgt_time_low	[OUT]	The target time low.
+ *  @param	tgt_time_high	[IN]	The target time high.
+ *  @retval	None
+*/
+static INLINE void
+ioh_1588_tgt_snap_get(unsigned long *tgt_time_low, unsigned long *tgt_time_high)
+{
+	/* Get the Target Time Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_TTL_OFFSET, tgt_time_low);
+
+	/* Get the Target Time High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_TTH_OFFSET, tgt_time_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_addend_set(unsigned long fsv)
+ *  @brief  	Set Frequency Scaling Value
+ *  @param	fsv	[IN]	Frequency
+ *  @retval	None
+*/
+static INLINE void ioh_1588_addend_set(unsigned long fsv)
+{
+	/* Update the Addend Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_ADD_OFFSET, fsv);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_addend_get(unsigned long *fsv)
+ *  @brief	Get Frequency Scaling Value
+ *  @param	fsv	[OUT]	The frequency.
+ *  @retval	None
+*/
+static INLINE void ioh_1588_addend_get(unsigned long *fsv)
+{
+	/* Get the Addend Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_ADD_OFFSET, fsv);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_pps_set(unsigned long pps)
+ *  @brief 	Set Pulse Per Second Value
+ *  @param	pps	[IN]	The pulse per second value.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_pps_set(unsigned long pps)
+{
+	/* Update the PPS Compare Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_PPS_OFFSET, pps);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_pps_get(unsigned long *pps)
+ *  @brief	Get Pulse Per Second Value
+ *  @param	pps	[OUT]	The pulse per second value.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_pps_get(unsigned long *pps)
+{
+	/* Get the PPS Compare Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_PPS_OFFSET, pps);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_aux_master_snap_get(
+ *			unsigned long *amms_low, unsigned long *amms_high)
+ *  @brief	Get AMMS value
+ *  @param	amms_low	[OUT]	AMMS low value.
+ *  @param	amms_high	[OUT]	AMMS high value.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_aux_master_snap_get(unsigned long *amms_low, unsigned long *amms_high)
+{
+	/* Get the Auxiliary Master Mode Snapshot Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_AMSL_OFFSET, amms_low);
+
+	/* Get the Auxiliary Master Mode Snapshot High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_AMSH_OFFSET, amms_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_aux_slave_snap_get(
+ *			unsigned long *asms_low, unsigned long *asms_high)
+ *  @brief 	Get ASMS value
+ *  @param	asms_low	[OUT]	The ASMS low value.
+ *  @param	asms_high	[OUT]	The ASMS high value.
+ *  @retval	None
+*/
+static INLINE void
+ioh_1588_aux_slave_snap_get(unsigned long *asms_low, unsigned long *asms_high)
+{
+	/* Get the Auxiliary Slave Mode Snapshot Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_ASSL_OFFSET, asms_low);
+
+	/* Get the Auxiliary Slave Mode Snapshot High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_ASSH_OFFSET, asms_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_master_mode_set(
+ *						unsigned long master_mode)
+ *  @brief 	Set the channel mode to 1588 Master/Slave
+ *  @param	master_mode	[IN]	The channel mode.
+ *  @retval	None
+*/
+static INLINE void ioh_1588_master_mode_set(unsigned long master_mode)
+{
+	/* SET or CLEAR the Master Mode */
+	if (TRUE == master_mode) {
+		IOH_DEBUG("ioh_1588_master_mode_set: setting master mode\n");
+		/* SET the mm bit */
+		IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_MM);
+	} else {
+		IOH_DEBUG("ioh_1588_master_mode_set: clearing master mode\n");
+		/* CLEAR the mm bit */
+		IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_MM);
+	}
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_master_mode_get (void)
+ *  @brief	Check for 1588 master mode of channel
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_master_mode_get(void)
+{
+	/* Is the mm bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_MM);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_timestamp_all_set(
+ *							unsigned long allMsg)
+ *  @brief	Set Timestamp all or only PTP messages flag
+ *  @param	allMsg	[IN]	All/PTP messages.
+ *  @retval	None
+*/
+static INLINE void ioh_1588_timestamp_all_set(unsigned long allMsg)
+{
+	/* SET or CLEAR the All Message Timestamping */
+	if (TRUE == allMsg) {
+		IOH_DEBUG
+		    ("ioh_1588_timestamp_all_set: time stamp all messages\n");
+		/* SET the ta bit */
+		IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_TA);
+	} else {		/* else of if (TRUE == allMsg) */
+
+		IOH_DEBUG
+		    ("ioh_1588_timestamp_all_set: time stamp PTP messages \
+								only\n");
+		/* CLEAR the ta bit */
+		IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_TA);
+	}
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_timestamp_all_get(void)
+ *  @brief	Check for Timestamp all OR only PTP messages flag
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_timestamp_all_get(void)
+{
+	/* Is the ta bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_TA);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_version_set(
+ *		unsigned long versionVal)
+ *  @brief	Set the 1588 version number
+ *  @param	versionVal	[IN]	The version value.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_version_set(unsigned long versionVal)
+{
+	if (TRUE == versionVal) {
+		IOH_DEBUG
+		    ("ioh_1588_version_set supports IEEE1588 v1 and \
+							IEEE1588-2008\n");
+		/* SET the version bit */
+		IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_VERSION);
+	} else {
+		IOH_DEBUG("ioh_1588_version_set supports IEEE1588 v1 only\n");
+		/* CLEAR the version bit */
+		IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_VERSION);
+	}
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_version_get (void)
+ *  @brief	Get the 1588 version number
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_version_get(void)
+{
+	/* Is the version bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CC_OFFSET,
+				 IOH_1588_CC_VERSION);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_can_snap_valid (void)
+ *  @brief 	CAN Timestamp available
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_can_snap_valid(void)
+{
+	/* Is the valid bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CCE_OFFSET,
+				 IOH_1588_CE_VAL);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_can_snap_ovr(void)
+ *  @brief	CAN Timestamp overrun
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_can_snap_ovr(void)
+{
+	/* Is the ovr bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CCE_OFFSET,
+				 IOH_1588_CE_OVR);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_can_snap_valid_clear(void)
+ *  @brief	Clear CAN Timestamp valid flag
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_can_snap_valid_clear(void)
+{
+	/* CLEAR the valid bit by writing '1' onto it */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_CCE_OFFSET, IOH_1588_CE_VAL);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_can_snap_ovr_clear(void)
+ *  @brief	Clear CAN Timestamp overrun flag
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_can_snap_ovr_clear(void)
+{
+	/* CLEAR the overrun bit */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_CCE_OFFSET, IOH_1588_CE_OVR);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_rx_snap_evt(void)
+ *  @brief	Receive Timestamp available
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_rx_snap_evt(void)
+{
+	/* Is the rxs bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CE_OFFSET,
+				 IOH_1588_CE_RXS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn
+ *  @brief	Transmit Timestamp available
+ *  @param	None
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_tx_snap_evt(void)
+{
+	/* Is the txs bit SET? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_CE_OFFSET,
+				 IOH_1588_CE_TXS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_rx_snap_evt_clear(void)
+ *  @brief	Clear Receive Timestamp available event
+ *  @param	None.
+ *  @retval	None.*/
+static INLINE void ioh_1588_rx_snap_evt_clear(void)
+{
+	/* CLEAR the rxs bit */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_CE_OFFSET, IOH_1588_CE_RXS);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_tx_snap_evt_clear(void)
+ *  @brief	Clear Transmit Timestamp available event
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_tx_snap_evt_clear(void)
+{
+	unsigned long ev_reg;
+
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CE_OFFSET, &ev_reg);
+	IOH_DEBUG
+	("ioh_1588_tx_snap_evt_clear event reg content before clearing= %lx\n",
+		ev_reg);
+
+	/* CLEAR the txs bit */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_CE_OFFSET, IOH_1588_CE_TXS);
+
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CE_OFFSET, &ev_reg);
+	IOH_DEBUG
+	("ioh_1588_tx_snap_evt_clear event reg content after clearing= %lx\n",
+		ev_reg);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_can_snap_get(
+ *				unsigned long *rxs_low,unsigned long *rxs_high)
+ *  @brief	Get PTP CAN Port Timestamp value
+ *  @param	rxs_low		[OUT]	The CAN Rx low value.
+ *  @param	rxs_high	[OUT]	The CAN Rx high value.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_can_snap_get(unsigned long *rxs_low, unsigned long *rxs_high)
+{
+	/* Get the Receive Timestamp/Snapshot Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CXSL_OFFSET, rxs_low);
+
+	/* Get the Receive Timestamp/Snapshot High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CXSH_OFFSET, rxs_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_rx_snap_get(
+ *				unsigned long *rxs_low, unsigned long *rxs_high)
+ *  @brief	Get PTP Port Rx Timestamp value
+ *  @param	rxs_low		[OUT]	The Snap Rx value.
+ *  @param	rxs_high	[OUT]	The Snap Rx Value.
+ *  @reatval	None
+*/
+static INLINE void
+ioh_1588_rx_snap_get(unsigned long *rxs_low, unsigned long *rxs_high)
+{
+	/* Get the Receive Timestamp/Snapshot Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_RSL_OFFSET, rxs_low);
+
+	/* Get the Receive Timestamp/Snapshot High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_RSH_OFFSET, rxs_high);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_tx_snap_get(
+ *				unsigned long *txs_low, unsigned long *txs_high)
+ *  @brief 	Get PTP Port Tx Timestamp value
+ *  @param	txs_low		[OUT]	The Port Tx value low.
+ *  @param	txs_high	[OUT]	The Port Tx value high.
+ *  @retval	None
+*/
+static INLINE void
+ioh_1588_tx_snap_get(unsigned long *txs_low, unsigned long *txs_high)
+{
+	/* Get the Transmit Timestamp/Snapshot Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_XSL_OFFSET, txs_low);
+
+	/* Get the Transmit Timestamp/Snapshot High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_XSH_OFFSET, txs_high);
+
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn	static INLINE void ioh_1588_uuid_seqid_get(
+ *	unsigned long *uuid_low,unsigned long *uuid_high, unsigned int *seq_id)
+ *  @brief 	Get UUID High (16-bit value) & Sequence ID (16-bit value) of
+ *		 PTP message
+ *  @param	uuid_low	[OUT]	The UUID low value.
+ *  @param	seq_id		[OUT]	The sequence ID.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_uuid_seqid_get(unsigned long *uuid_low,
+			unsigned long *uuid_high, unsigned int *seq_id)
+{
+	unsigned long regval = 0;
+
+	/* Get the UUID Low Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_UID_OFFSET, uuid_low);
+
+	/* Get the Sequence ID and Source UUID High Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_SID_OFFSET, &regval);
+
+	*seq_id = (regval >> IOH_1588_SID_LOC);
+	*uuid_high = (regval & IOH_1588_LSB_SHORT_MASK);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_op_mode_set(unsigned long mode)
+ *  @brief	Sets the operation mode.
+ *  @param	mode	[IN]	The mode value.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_op_mode_set(unsigned long mode)
+{
+	unsigned long regval;
+
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CC_OFFSET, &regval);
+	regval =
+	    (regval & ~IOH_1588_CC_MODE_MASK) | (mode <<
+						 IOH_1588_CC_MODE_SHIFT);
+	/* set the operaion mode bits */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_CC_OFFSET, regval);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_op_mode_get(void)
+ *  @brief	Gets the operation mode.
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_op_mode_get(void)
+{
+	unsigned long regval;
+	unsigned long mode;
+
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_CC_OFFSET, &regval);
+	/* get the operaion mode bits */
+	mode = (regval & IOH_1588_CC_MODE_MASK) >> IOH_1588_CC_MODE_SHIFT;
+
+	return mode;
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_eth_enable_set(void)
+ *  @brief	Enbales the eth.
+ *  @param	None.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_eth_enable_set(void)
+{
+	/* SET the eth_enable bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_ECS_OFFSET, IOH_1588_ECS_ETH);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_eth_enable_clear(void)
+ *  @brief	Clears the eth enable.
+ *  @param	None.
+ *  @retval	None.
+*/
+static INLINE void ioh_1588_eth_enable_clear(void)
+{
+	/* Clear the eth_enable bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_ECS_OFFSET, IOH_1588_ECS_ETH);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_eth_enable_get(void)
+ *  @brief	Gets the eth enable.
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_eth_enable_get(void)
+{
+	/* Is eth_enable bit set? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_ECS_OFFSET,
+				 IOH_1588_ECS_ETH);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_can_enable_set(void)
+ *  @brief	Sets the CAN enable.
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_can_enable_set(void)
+{
+	/* SET the can_enable bit */
+	IOH_SET_ADDR_BIT(ioh_1588_base + IOH_1588_ECS_OFFSET, IOH_1588_ECS_CAN);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_can_enable_clear(void)
+ *  @brief	Sets the CAN enable clear
+ *  @param	None
+ *  @retval	None
+*/
+static INLINE void ioh_1588_can_enable_clear(void)
+{
+	/* Clear the can_enable bit */
+	IOH_CLR_ADDR_BIT(ioh_1588_base + IOH_1588_ECS_OFFSET, IOH_1588_ECS_CAN);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE unsigned long ioh_1588_can_enable_get(void)
+ *  @brief	Gets the CAN enable status.
+ *  @param	None.
+ *  @retval	unsigned long
+*/
+static INLINE unsigned long ioh_1588_can_enable_get(void)
+{
+	/* Is can_enable bit set? */
+	return IOH_BIT_SET_CHECK(ioh_1588_base + IOH_1588_ECS_OFFSET,
+				 IOH_1588_ECS_CAN);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_station_set(unsigned long station,
+ *		 unsigned long value)
+ *  @brief	Set the station[1-6] address to be used in PTP message
+ *  @param	station		[IN]	The Station.
+ *  @param	value		[IN]	The Value.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_station_set(unsigned long station, unsigned long value)
+{
+	IOH_DEBUG("ioh_1588_station_set;setting station address=%lx\n", value);
+	/* Set the Station Address Register contents */
+	IOH_REG_32_WRITE(ioh_1588_base + IOH_1588_STA_OFFSET +
+			 station * sizeof(int), value);
+}
+
+/*! @ingroup	IEEE_1588_HALLayerAPI
+ *  @fn		static INLINE void ioh_1588_station_get (unsigned long station,
+ *		 unsigned long *value)
+ *  @brief 	Get the station[1-6] address used in PTP message
+ *  @param	station		[IN]	The station.
+ *  @param	value		[OUT]	The value.
+ *  @retval	None.
+*/
+static INLINE void
+ioh_1588_station_get(unsigned long station, unsigned long *value)
+{
+	/* Get the Station Address Register contents */
+	IOH_REG_32_READ(ioh_1588_base + IOH_1588_STA_OFFSET +
+			station * sizeof(int), value);
+	*value &= 0xFF;		/* only one byte */
+}
+
+/**
+ * Support functions definitions
+ */
+
+/**
+ * @ingroup	IEEE_1588_HALLayerAPI
+ * @fn		enum ioh_status ioh_1588_disable_interrupts(void)
+ * @brief	Disables all interrupts on the 1588 device.
+ * @param   	None
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+
+enum ioh_status ioh_1588_disable_interrupts(void)
+{
+	if (ioh_1588_base != 0) {
+		IOH_DEBUG
+		    ("ioh_1588_disable_interrupts:invoking \
+						ioh_1588_ttm_imask_clear\n");
+		ioh_1588_ttm_imask_clear();
+		IOH_DEBUG
+		    ("ioh_1588_disable_interrupts:invoking \
+						ioh_1588_asms_imask_clear\n");
+		ioh_1588_asms_imask_clear();
+		IOH_DEBUG
+		    ("ioh_1588_disable_interrupts:invoking \
+						ioh_1588_amms_imask_clear\n");
+		ioh_1588_amms_imask_clear();
+		IOH_DEBUG
+		    ("ioh_1588_disable_interrupts:invoking \
+						ioh_1588_pps_imask_clear\n");
+		ioh_1588_pps_imask_clear();
+	}
+	return IOH_1588_SUCCESS;
+}
+
+/**
+ * @ingroup	IEEE_1588_HALLayerAPI
+ * @fn		enum ioh_status ioh_1588_interrupt_pending(
+ *		unsigned long *pending)
+ * @brief	Check whether there is any pending interrupts from the 1588
+ *		 device.
+ * @param   	pending	[IN]	Pending flag which set to TRUE if there is any
+ *		 pending interrupt
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_interrupt_pending(unsigned long *pending)
+{
+	*pending = FALSE;
+	if (ioh_1588_pps_evt_get() || ioh_1588_amms_evt_get() ||
+	    ioh_1588_asms_evt_get() || ioh_1588_ttm_evt_get()) {
+		IOH_DEBUG("ioh_1588_interrupt_pending:interrupt pending\n");
+		*pending = TRUE;
+	} else {
+		IOH_DEBUG("ioh_1588_interrupt_pending:NO interrupt pending\n");
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/**
+ * @ingroup	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh1588PTPPortMode ioh_1588_port_mode_get(
+ *		enum ioh1588PTPPort ptpPort)
+ * @brief 	Function to determine the port mode
+ * @param 	ptpPort   [IN] 	Interested port (GBE_0)
+ * @retval	enum ioh1588PTPPortMode
+ * 		- IOH_1588PTP_PORT_MASTER
+ * 		- IOH_1588PTP_PORT_SLAVE
+ * 		- IOH_1588PTP_PORT_ANYMODE
+ */
+enum ioh1588PTPPortMode ioh_1588_port_mode_get(enum ioh1588PTPPort ptpPort)
+{
+	/* Local variables */
+	unsigned long master_mode = FALSE;
+	unsigned long any_mode = FALSE;
+	enum ioh1588PTPPortMode port_mode = IOH_1588PTP_PORT_SLAVE;
+
+	/* Get the Mode of the PTP Port */
+	master_mode = ioh_1588_master_mode_get();
+	any_mode = ioh_1588_timestamp_all_get();
+
+	/* Is ANY mode (all message timestamp mode) on? */
+	if (TRUE == any_mode) {
+		IOH_DEBUG
+		    ("ioh_1588_port_mode_get:all messages being timestamped\n");
+		/*
+		 * When Any mode is set, all messages are time stamped,
+		 * irrespective of the Master/Slave mode bit
+		 */
+		port_mode = IOH_1588PTP_PORT_ANYMODE;
+		IOH_DEBUG
+		    ("ioh_1588_port_mode_get:port_mode = \
+						IOH_1588PTP_PORT_ANYMODE\n");
+	} else {
+		/* Is Master mode on? */
+		if (TRUE == master_mode) {
+			port_mode = IOH_1588PTP_PORT_MASTER;
+			IOH_DEBUG
+			    ("ioh_1588_port_mode_get:port_mode = \
+						IOH_1588PTP_PORT_MASTER\n");
+		} else {
+			port_mode = IOH_1588PTP_PORT_SLAVE;
+			IOH_DEBUG
+			    ("ioh_1588_port_mode_get:port_mode = \
+						IOH_1588PTP_PORT_SLAVE\n");
+		}
+	}
+
+	return port_mode;
+}
+
+/*
+ *                        Public API definitions
+ */
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn 	enum ioh_status ioh_1588_blpl_base_address_set(unsigned long base_addr)
+ *
+ * @brief 	Function sets the virtual address of registers
+ * @remarks	This API will set the starting virtual addresses for the
+ * 		1588 hardware registers. The main tasks performed by this
+ *		 function are:
+ * 		- If the aargument passed is NULL, return status
+ *		 IOH_1588_INVALIDPARAM
+ * 		- Set base address of IEEE 1588 registers to specified value
+ *
+ *
+ * @param 	base_addr [IN] - Virtual address of IEEE 1588 module registers
+ *
+ * @retval 	enum ioh_status
+ * 	   @li IOH_1588_SUCCESS - Operation successful
+ *         @li IOH_1588_INVALIDPARAM - Invalid parameter passed
+ */
+enum ioh_status ioh_1588_blpl_base_address_set(unsigned long base_addr)
+{
+	if (!base_addr) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_blpl_base_address_set:invalid base address\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	ioh_1588_base = base_addr;
+	IOH_DEBUG("ioh_1588_blpl_base_address_set:base address=%lx\n",
+		  ioh_1588_base);
+
+	/* Initialize the callback pointers */
+	ioh_tt_cbptr = (ioh1588TargetTimeCallback) NULL;
+	ioh_am_cbptr = (ioh1588AuxTimeCallback) NULL;
+	ioh_as_cbptr = (ioh1588AuxTimeCallback) NULL;
+	ioh_pps_cbptr = (ioh1588PulsePerSecondCallback) NULL;
+	IOH_DEBUG("ioh_1588_blpl_base_address_set:initialized callback ptrs\n");
+
+	/* Reset the statistics counters */
+	ioh_1588_stats.rxMsgs = ioh_1588_stats.txMsgs = 0;
+	IOH_DEBUG("ioh_1588_blpl_base_address_set:reset statistics counters\n");
+
+	/* Clear availability of various events */
+	IOH_DEBUG
+	    ("ioh_1588_blpl_base_address_set:invoking \
+						ioh_1588_pps_evt_clear\n");
+	ioh_1588_pps_evt_clear();
+	IOH_DEBUG
+	    ("ioh_1588_blpl_base_address_set:invoking \
+						ioh_1588_ttm_evt_clear\n");
+	ioh_1588_ttm_evt_clear();
+	IOH_DEBUG
+	    ("ioh_1588_blpl_base_address_set:invoking \
+						ioh_1588_amms_evt_clear\n");
+	ioh_1588_amms_evt_clear();
+	IOH_DEBUG
+	    ("ioh_1588_blpl_base_address_set:invoking \
+						ioh_1588_asms_evt_clear\n");
+	ioh_1588_asms_evt_clear();
+
+	IOH_DEBUG("ioh_1588_blpl_base_address_set:returning success\n");
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_port_config_set(
+ *	enum ioh1588PTPPort ptpPort, enum ioh1588PTPPortMode ptpPortMode)
+ *
+ * @brief Configure IEEE 1588 Hardware Assist message detection on a given PTP
+ *	 port
+ *
+ * @remarks	This API enables the time stamping on a particular PTP port.
+ * 		The main tasks performed by this function are:
+ * 		-	Validate the parameters and return
+ *			 IOH_1588_INVALIDPARAM, if found invalid
+ * 		-	Modify the TS_Channel_Control register to set the
+ *			 requested mode
+ *
+ *
+ * @param 	ptpPort [IN] - port on which PTP message detection to be enabled
+ * @param 	ptpPortMode [IN]- Master/Slave/All messages
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ */
+enum ioh_status
+ioh_1588_ptp_port_config_set(enum ioh1588PTPPort ptpPort,
+			     enum ioh1588PTPPortMode ptpPortMode)
+{
+	/* Verify the parameters for proper values */
+	if (ptpPort != IOH_1588_GBE_0_1588PTP_PORT) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ptp_port_config_set:invalid ptp port\
+			returning IOH_1588_GBE_0_1588PTP_PORT\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Set the Mode of the PTP Port */
+	switch (ptpPortMode) {
+	case IOH_1588PTP_PORT_MASTER:
+		{
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:port_mode=\
+				IOH_1588PTP_PORT_MASTER\n");
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_master_mode_set \
+				with param TRUE\n");
+			ioh_1588_master_mode_set(TRUE);
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_timestamp_all_set \
+				with param FALSE\n");
+			ioh_1588_timestamp_all_set(FALSE);
+			break;
+		}
+	case IOH_1588PTP_PORT_SLAVE:
+		{
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:port_mode=\
+				IOH_1588PTP_PORT_SLAVE\n");
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_master_mode_set \
+				with param FALSE\n");
+			ioh_1588_master_mode_set(FALSE);
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_timestamp_all_set \
+				with param FALSE\n");
+			ioh_1588_timestamp_all_set(FALSE);
+			break;
+		}
+	case IOH_1588PTP_PORT_ANYMODE:
+		{
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:port_mode=\
+				IOH_1588PTP_PORT_ANYMODE\n");
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_master_mode_set \
+				with param FALSE\n");
+			ioh_1588_master_mode_set(FALSE);
+			IOH_DEBUG
+			    ("ioh_1588_ptp_port_config_set:invoking \
+				ioh_1588_timestamp_all_set \
+				with param TRUE\n");
+			ioh_1588_timestamp_all_set(TRUE);
+			break;
+		}
+	default:
+		{
+			IOH_LOG(KERN_ERR, "ioh_1588_ptp_port_config_set: \
+				Invalid Port Mode (%d) \
+				returning IOH_1588_INVALIDPARAM\n",
+				ptpPortMode);
+			return IOH_1588_INVALIDPARAM;
+		}
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_port_config_get(
+ *			enum ioh1588PTPPort ptpPort,
+ *			enum ioh1588PTPPortMode *ptpPortMode)
+ *
+ * @brief 	Get the configuration of IEEE 1588 Hardware Assist message
+ *		 detection
+ * 		for given PTP port
+ *
+ * @remarks	This API retrieves the time stamping configuration of the given
+ *		 PTP port.
+ * 		The main tasks performed by this function are:
+ * 		-	Validate the parameters and return
+ *			 IOH_1588_INVALIDPARAM, if found invalid
+ * 		-	Return the current master/slave mode from
+ *			 TS_Channel_Control register
+ *
+ *
+ * @param 	ptpPort 	[IN]  	port for which PTP message configuration
+ *					 to be obtained
+ * @param 	ptpPortMode 	[OUT]	Master/Slave/All messages
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ */
+enum ioh_status
+ioh_1588_ptp_port_config_get(enum ioh1588PTPPort ptpPort,
+			     enum ioh1588PTPPortMode *ptpPortMode)
+{
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) ||
+	    ((enum ioh1588PTPPortMode *) NULL == ptpPortMode)) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ptp_port_config_get:\
+			invalid port_mode or port \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Get the Mode of the PTP Port */
+	IOH_DEBUG
+	    ("ioh_1588_ptp_port_config_get:invoking ioh_1588_port_mode_get\n");
+	*ptpPortMode = ioh_1588_port_mode_get(ptpPort);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_rx_poll(
+ *		enum ioh1588PTPPort ptpPort,
+ *		struct ioh1588PtpMsgData  *ptpMsgData)
+ *
+ * @brief 	Poll the IEEE 1588 Hardware Assist receive side message/time
+ *		 stamp
+ * 		detection status for given PTP Port
+ *
+ * @remarks	This API will poll for the availability of a time stamp on the
+ * 		received Sync (in slave mode) or Delay_Req (in master mode)
+ *		 messages.
+ * 		The buffer is provided by the caller.
+ * 		The steps performed in this function are:
+ * 		- If ptpPort not valid or ptpMsgData is NULL return
+ *		 IOH_1588_INVALID_PARAM
+ * 		- Find out whether locked /unlocked mode.
+ * 		- If locked mode ,check the TS_Channel_Event register for Rx
+ *		 event
+ * 		- If locked mode, return NO TIMESTAMP if no Rx event flag is
+ *		 set.
+ * 		- Read the time stamp from RECV_Snapshot low, high and
+ * 		- SourceUUID0 low, high registers
+ * 		- Clear SourceUUId if the mode is not master/slave and PTP v1
+ *		 only.
+ * 		- Increment RX messages captured statistics counter
+ * 		- If locked mode ,clear the RX event is TS_Channel_Event
+ *		 register
+ *
+ *
+ * @param 	ptpPort 	[IN] 	port on which time stamp availability
+ *					 to be checked
+ * @param 	ptpMsgData 	[out] 	Captured time stamp and other message
+ *					 information
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ *      @li IOH_1588_NOTIMESTAMP - Time stamp not available
+ *      @li IOH_1588_FAILED - Internal error occurred
+ */
+enum ioh_status
+ioh_1588_ptp_rx_poll(enum ioh1588PTPPort ptpPort, \
+			struct ioh1588PtpMsgData *ptpMsgData)
+{
+	unsigned long locked_mode = FALSE;
+
+	enum ioh1588PTPPortMode port_mode = IOH_1588PTP_PORT_MODE_INVALID;
+	enum ioh1588PTPVersion ptpVersion = IOH_1588PTP_VERSION_INVALID;
+	enum ioh1588PTPOperationMode opMode = IOH_1588PTP_OP_MODE_INVALID;
+
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) ||
+	    ((struct ioh1588PtpMsgData *) NULL == ptpMsgData)) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ptp_rx_poll:invalid port or ptp message \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/*Get the PTP version */
+	ptpVersion = ioh_1588_version_get();
+
+	/*check if locked/unlocked mode */
+	if (ptpVersion == IOH_1588PTP_VERSION_0) {	/*PTP v1 only */
+		/* Get the Mode of the PTP Port if only PTPv1 is supported */
+		port_mode = ioh_1588_port_mode_get(ptpPort);
+		if (port_mode != IOH_1588PTP_PORT_ANYMODE)
+			locked_mode = TRUE;
+	} else {		/*PTP v1 & v2 */
+
+		/*get operation mode */
+		opMode = ioh_1588_op_mode_get();
+		if ((opMode != IOH_1588PTP_OP_MODE_V1_ALL_MSGS) &&
+			(opMode != IOH_1588PTP_OP_MODE_V1_V2_ALL_MSGS)) {
+			locked_mode = TRUE;
+		}
+	}
+
+	/*if locked mode,check event flag */
+	if ((TRUE == locked_mode) && (TRUE != ioh_1588_rx_snap_evt())) {
+		IOH_DEBUG
+		("ioh_1588_ptp_rx_poll:locked mode-event flag not set\n");
+		IOH_DEBUG("ioh_1588_ptp_rx_poll:NO TIMESTAMP \
+			returning IOH_1588_NOTIMESTAMP\n");
+		return IOH_1588_NOTIMESTAMP;
+	}
+
+	/* Fetch the receive timestamp */
+	IOH_DEBUG("ioh_1588_ptp_rx_poll:invoking ioh_1588_rx_snap_get\n");
+	ioh_1588_rx_snap_get(&ptpMsgData->ptpTimeStamp.timeValueLowWord,
+				&ptpMsgData->ptpTimeStamp.timeValueHighWord);
+
+	IOH_DEBUG
+	    ("ioh_1588_ptp_rx_poll:ioh_1588_ptp_rx_poll Snapshot (Hi:Low): \
+		%lx : %lx\n",
+	     ptpMsgData->ptpTimeStamp.timeValueHighWord,
+	     ptpMsgData->ptpTimeStamp.timeValueLowWord);
+
+	/* Fetch the UUID & Seq# of PTP messages in 'Master/Slave Mode' only */
+	if ((TRUE == locked_mode) && (IOH_1588PTP_VERSION_0 == ptpVersion)) {
+		IOH_DEBUG
+		    ("ioh_1588_ptp_rx_poll:invoking ioh_1588_uuid_seqid_get\n");
+		ioh_1588_uuid_seqid_get(&ptpMsgData->ptpUuid.uuidValueLowWord,
+					&ptpMsgData->ptpUuid.
+					uuidValueHighHalfword,
+					&ptpMsgData->ptpSequenceNumber);
+	}
+	/* Clear-off the UUID & Seq# of all the messages in 'Any Mode' */
+	else {
+		IOH_DEBUG
+		    ("ioh_1588_ptp_rx_poll:port mode is ANYMODE,clearing off \
+			UUID & SeqNumber\n");
+		ptpMsgData->ptpUuid.uuidValueLowWord = 0;
+		ptpMsgData->ptpUuid.uuidValueHighHalfword = 0;
+		ptpMsgData->ptpSequenceNumber = 0;
+	}
+
+	/* Increment receive timestamp counter
+	 * Note:In unlocked modes,this will get incremented
+	 * for every rx time stamp poll.
+	 */
+	ioh_1588_stats.rxMsgs++;
+	IOH_DEBUG("ioh_1588_ptp_rx_poll:incremented rcv timestamp \
+			counter=%ld\n", ioh_1588_stats.rxMsgs);
+
+	/*
+	 * Fill-in the PTP message type.This can be done
+	 * only when PTP v1 alone is supported and mode
+	 * is master/slave.Set the message type as unknown
+	 * for all other cases.
+	 */
+	if (ptpVersion == IOH_1588PTP_VERSION_0) {	/*PTP v1 only */
+		switch (port_mode) {
+		case IOH_1588PTP_PORT_MASTER:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_rx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_DELAYREQ\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_DELAYREQ;
+				break;
+			}
+		case IOH_1588PTP_PORT_SLAVE:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_rx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_SYNC\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_SYNC;
+				break;
+			}
+		case IOH_1588PTP_PORT_ANYMODE:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_rx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_UNKNOWN\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_UNKNOWN;
+				break;
+			}
+		default:
+			{
+				IOH_LOG(KERN_ERR,
+					"ioh_1588_ptp_rx_poll(): Invalid Port \
+					Mode \
+					returning IOH_1588_FAILED\n");
+				return IOH_1588_FAILED;
+			}
+		}
+	} else {		/*PTP v1 & v2 */
+
+		IOH_DEBUG
+		("ioh_1588_ptp_rx_poll:PTP message type=\
+			IOH_1588PTP_MSGTYPE_UNKNOWN\n");
+		ptpMsgData->ptpMsgType = IOH_1588PTP_MSGTYPE_UNKNOWN;
+	}
+
+	/* If locked mode allow next timestamp to be captured */
+	if (TRUE == locked_mode) {
+		IOH_DEBUG
+		("ioh_1588_ptp_rx_poll:invoking \
+			ioh_1588_rx_snap_evt_clear\n");
+		ioh_1588_rx_snap_evt_clear();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_tx_poll(
+ *		enum ioh1588PTPPort ptpPort,
+ *		struct ioh1588PtpMsgData  *ptpMsgData)
+ *
+ * @brief 	Poll the IEEE 1588 Hardware Assist transmit side message/time
+ *		 stamp
+ * 		detection status for given PTP Port
+ *
+ * @remarks	This API will poll for the availability of a time stamp on the
+ * 		transmit side Sync (in master mode) or Delay_Req (in slave mode)
+ *		 messages.
+ * 		The buffer is provided by the caller.
+ * 		The main tasks performed by this function are:
+ * 		- If ptpPort not valid or ptpMsgData is NULL
+ *		 return IOH_1588_INVALID_PARAM
+ * 		- Find out whether locked /unlocked mode.
+ * 		- If locked mode ,check the TS_Channel_Event register for Tx
+ *		 event
+ * 		- If locked mode, return NO TIMESTAMP if no Tx event flag is
+ *		 set.
+ * 		- Read the time stamp from XMIT_Snapshot low, high registers
+ * 		- Increment TX messages captured statistics counter
+ * 		- If locked mode, clear the TX event is TS_Channel_Event
+ *		 register
+ *
+ *
+ * @param 	ptpPort [IN] 	port on which time stamp availability to be
+ *				 checked
+ * @param 	ptpMsgData [OUT] 	Captured time stamp and other message
+ *				 information
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ *      @li IOH_1588_NOTIMESTAMP - Time stamp not available
+ *      @li IOH_1588_FAILED - Internal error occurred
+ */
+enum ioh_status
+ioh_1588_ptp_tx_poll(enum ioh1588PTPPort ptpPort, \
+			struct ioh1588PtpMsgData *ptpMsgData)
+{
+	unsigned long locked_mode = FALSE;
+
+	enum ioh1588PTPPortMode port_mode = IOH_1588PTP_PORT_MODE_INVALID;
+	enum ioh1588PTPVersion ptpVersion = IOH_1588PTP_VERSION_INVALID;
+	enum ioh1588PTPOperationMode opMode = IOH_1588PTP_OP_MODE_INVALID;
+
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) ||
+	    ((struct ioh1588PtpMsgData *) NULL == ptpMsgData)) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ptp_tx_poll:invalid port or ptp message \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/*Get the PTP version */
+	ptpVersion = ioh_1588_version_get();
+
+	/*check if locked/unlocked mode */
+	if (ptpVersion == IOH_1588PTP_VERSION_0) {	/*PTP v1 only */
+		/* Get the Mode of the PTP Port if only PTPv1 is supported */
+		port_mode = ioh_1588_port_mode_get(ptpPort);
+		if (port_mode != IOH_1588PTP_PORT_ANYMODE)
+			locked_mode = TRUE;
+	} else {		/*PTP v1 & v2 */
+
+		/*get operation mode */
+		opMode = ioh_1588_op_mode_get();
+		if ((opMode != IOH_1588PTP_OP_MODE_V1_ALL_MSGS) &&
+		    (opMode != IOH_1588PTP_OP_MODE_V1_V2_ALL_MSGS)) {
+			locked_mode = TRUE;
+		}
+	}
+
+	/*if locked mode,check event flag */
+	if ((TRUE == locked_mode) && (TRUE != ioh_1588_tx_snap_evt())) {
+		IOH_DEBUG
+		    ("ioh_1588_ptp_tx_poll:locked mode-event flag not set\n");
+		IOH_DEBUG
+		    ("ioh_1588_ptp_tx_poll:ioh_1588_ptp_tx_poll NO TIMESTAMP \
+			returning IOH_1588_NOTIMESTAMP\n");
+		return IOH_1588_NOTIMESTAMP;
+	}
+
+	/* read time stamp registers */
+	ioh_1588_tx_snap_get(&ptpMsgData->ptpTimeStamp.timeValueLowWord,
+			     &ptpMsgData->ptpTimeStamp.timeValueHighWord);
+
+	IOH_DEBUG
+	("ioh_1588_ptp_tx_poll:ioh_1588_ptp_tx_poll Snapshot (Hi:Low): \
+		%lx : %lx\n",
+		ptpMsgData->ptpTimeStamp.timeValueHighWord,
+		ptpMsgData->ptpTimeStamp.timeValueLowWord);
+	/*
+	 * Fill the UUID and Seq# with invalid values (zeros)
+	 * since they are not relevant for transmit timestamp
+	 */
+	ptpMsgData->ptpUuid.uuidValueLowWord = 0;
+	ptpMsgData->ptpUuid.uuidValueHighHalfword = 0;
+	ptpMsgData->ptpSequenceNumber = 0;
+
+	/*
+	 * Increment transmit timestamp counter
+	 * Note:In unlocked modes,this will get incremented
+	 * for every tx time stamp poll
+	 */
+	ioh_1588_stats.txMsgs++;
+	IOH_DEBUG("ioh_1588_ptp_tx_poll:incremented tx timestamp counter=%ld\n",
+		  ioh_1588_stats.txMsgs);
+
+	/*
+	 * Fill-in the PTP message type.This can be done
+	 * only when PTP v1 alone is supported and mode
+	 * is master/slave.Set the message type as unknown
+	 * for all other cases.
+	 */
+	if (ptpVersion == IOH_1588PTP_VERSION_0) {	/*PTP v1 only */
+		switch (port_mode) {
+		case IOH_1588PTP_PORT_MASTER:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_tx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_SYNC\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_SYNC;
+				break;
+			}
+		case IOH_1588PTP_PORT_SLAVE:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_tx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_DELAYREQ\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_DELAYREQ;
+				break;
+			}
+		case IOH_1588PTP_PORT_ANYMODE:
+			{
+				IOH_DEBUG
+				("ioh_1588_ptp_tx_poll:PTP message type=\
+					IOH_1588PTP_MSGTYPE_UNKNOWN\n");
+				ptpMsgData->ptpMsgType =
+				    IOH_1588PTP_MSGTYPE_UNKNOWN;
+				break;
+			}
+		default:
+			{
+				IOH_LOG(KERN_ERR,
+					"ioh_1588_ptp_tx_poll(): \
+					Invalid Port Mode \
+					returning IOH_1588_FAILED\n");
+				return IOH_1588_FAILED;
+			}
+		}
+	} else {		/*PTP v1 & v2 */
+
+		IOH_DEBUG
+		("ioh_1588_ptp_tx_poll:PTP message type=\
+			IOH_1588PTP_MSGTYPE_UNKNOWN\n");
+		ptpMsgData->ptpMsgType = IOH_1588PTP_MSGTYPE_UNKNOWN;
+	}
+
+	/* If locked mode allow next timestamp to be captured */
+	if (locked_mode) {
+		IOH_DEBUG
+		("ioh_1588_ptp_tx_poll:invoking ioh_1588_tx_snap_evt_clear\n");
+		ioh_1588_tx_snap_evt_clear();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_system_time_set(
+ *		struct ioh1588TimeValue systemTime)
+ *
+ * @brief 	This API sets the system time to given value
+ * @remarks	Sets the System Time in the IEEE 1588 hardware assist block.
+ *
+ * @param 	systemTime [IN] 	value to set the system time to
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_system_time_set(struct ioh1588TimeValue systemTime)
+{
+	unsigned long old_fsv = 0;
+
+	/* Retrieve old Frequency Scaling Value */
+	IOH_DEBUG("ioh_1588_system_time_set:invoking ioh_1588_addend_get\n");
+	ioh_1588_addend_get(&old_fsv);
+	IOH_DEBUG("ioh_1588_system_time_set:existing freq scaling value=%lx\n",
+		  old_fsv);
+
+	/*
+	 * Set the Frequency Scaling Value to zero (0) so that
+	 * System Time doesn't get incremented while it is being written to
+	 */
+	IOH_DEBUG("ioh_1588_system_time_set:invoking ioh_1588_addend_set \
+			to set frequncy scaling value to 0\n");
+	ioh_1588_addend_set(0);
+
+	/* Update System Time with user specified values */
+	IOH_DEBUG("ioh_1588_system_time_set:invoking \
+			ioh_1588_ioh_1588_sys_snap_set \
+			with values low=%lx,high=%lx\n",
+		  systemTime.timeValueLowWord, systemTime.timeValueHighWord);
+	ioh_1588_sys_snap_set(systemTime.timeValueLowWord,
+			      systemTime.timeValueHighWord);
+
+	/*
+	 * Let the hardware assist re-evaluate the target time reached
+	 * condition based on the new system time
+	 */
+	IOH_DEBUG("ioh_1588_system_time_set:invoking ioh_1588_ttm_evt_clear\n");
+	ioh_1588_ttm_evt_clear();
+
+	/*
+	 * Restore old Frequency Scaling Value so that System Time
+	 * can be incremented
+	 */
+	IOH_DEBUG("ioh_1588_system_time_set:invoking ioh_1588_addend_set \
+	to restore freq scaling value\n");
+	ioh_1588_addend_set(old_fsv);
+
+	IOH_DEBUG("ioh_1588_system_time_set:returning IOH_1588_SUCCESS\n");
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_system_time_get(
+ *		struct ioh1588TimeValue *systemTime)
+ *
+ * @brief 	Gets the System Time from the IEEE 1588 hardware assist block
+ * @remarks 	This API gets the System time.
+ * 		The main steps followed in this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Return the current system time by reading the SystemTime low,
+ *		 high registers
+ *
+ *
+ * @param 	systemTime [OUT] - Address to which system time is to be
+ *		 returned
+ *
+ * @return enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid address passed
+ */
+enum ioh_status ioh_1588_system_time_get(struct ioh1588TimeValue *systemTime)
+{
+	/* Verify the parameter */
+	if ((struct ioh1588TimeValue *) NULL == systemTime) {
+		IOH_LOG(KERN_ERR, "ioh_1588_system_time_get:invalid parameter \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Fetch System Time */
+	ioh_1588_sys_snap_get(&systemTime->timeValueLowWord,
+			      &systemTime->timeValueHighWord);
+
+	IOH_DEBUG("ioh_1588_system_time_get:invoked \
+			ioh_1588_ioh_1588_sys_snap_get \
+			system time:low=%lx,high=%lx\n",
+		  systemTime->timeValueLowWord, systemTime->timeValueHighWord);
+	IOH_DEBUG("ioh_1588_system_time_get returning IOH_1588_SUCCESS\n");
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_tick_rate_set(unsigned long tickRate)
+ *
+ * @brief 	Sets the Frequency Scaling Value in the IEEE 1588 hardware
+ *		 assist block
+ *
+ * @remarks	This API sets the Tick Rate (Frequency Scaling Value) in the
+ * 		IEEE 1588 block. This value determines the progress at which
+ * 		the System time advances.
+ *		Note: For the A1 hardware sample, the addend register value
+ *		 configured in the hardware
+ *		is calculated as follows:
+ * 		Addend register value = Logical right shift tickRate by 1 and
+ *		 set MSB to 1
+ *
+ * @param 	tickRate [IN] 	Frequency scaling value
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_tick_rate_set(unsigned long tickRate)
+{
+	/* Update the Frequency Scaling Value */
+#ifdef IOH_IEEE1588_A1_SAMPLE_BUG
+	/*back up tick rate provided by app */
+	gTickRateApp = tickRate;
+	/*calculate actual tick rate for device */
+	IOH_DEBUG("ioh_1588_tick_rate_set:tick rate [app]=%lx\n", tickRate);
+	tickRate = ((tickRate >> 1) | 0x80000000);
+	IOH_DEBUG("ioh_1588_tick_rate_set:tick rate [dev]=%lx\n", tickRate);
+#endif
+	IOH_DEBUG("ioh_1588_tick_rate_set:invoking ioh_1588_addend_set \
+			with tick rate=%lx\n", tickRate);
+	ioh_1588_addend_set(tickRate);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_tick_rate_get(unsigned long *tickRate)
+ *
+ * @brief 	Gets the Frequency Scaling Value from the IEEE 1588 hardware
+ *		 assist block
+ *
+ * @remarks	This API gets the Tick Rate (Frequency Scaling Value) used in
+ *		 the IEEE 1588 block.
+ * 		This value determines the progress at which the System time
+ *		 advances.
+ * 		The main steps followed in this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Return the content of Addend register
+ *
+ *
+ * @param 	tickRate [IN] - Address where current Frequency scaling value is
+ *		 returned
+ *
+ * @return	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARM - Invalid address passed
+ */
+enum ioh_status ioh_1588_tick_rate_get(unsigned long *tickRate)
+{
+	/* Verify the parameter */
+	if ((unsigned long *)NULL == tickRate) {
+		IOH_LOG(KERN_ERR, "ioh_1588_tick_rate_get:invalid tick rate\
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+#ifdef IOH_IEEE1588_A1_SAMPLE_BUG
+	/* Retrieve Frequency Scaling Value stored in software buffer */
+	*tickRate = gTickRateApp;
+#else
+	/* Retrieve Current Frequency Scaling Value */
+	ioh_1588_addend_get(tickRate);
+#endif
+	IOH_DEBUG("ioh_1588_tick_rate_get:invoked ioh_1588_addend_get\
+			the tick rate=%lx\n", *tickRate);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_target_time_interrupt_enable(
+ *		ioh1588TargetTimeCallback callBack)
+ *
+ * @brief 	Enable the target time reached/exceeded system time interrupt
+ *
+ * @remarks	This API enables the interrupt that occurs when the System time
+ * 		reaches the Target time set in the IEEE 1588 hardware assist
+ *		 block.
+ * 		The main steps followed in this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Modify Time Sync Control Register to enable target time
+ *		 interrupt
+ * 		- Set the handler to callback function provided
+ *
+ *
+ * @param 	callBack [IN] - Routine to be invoked when target time reached
+ * 				interrupt occurs
+ *
+ * @retval	enum ioh_status
+ *  	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed for callback
+ */
+enum ioh_status
+ioh_1588_target_time_interrupt_enable(ioh1588TargetTimeCallback callBack)
+{
+	/* Verify the parameter */
+	if ((ioh1588TargetTimeCallback) NULL == callBack) {
+		IOH_LOG(KERN_ERR, "ioh_1588_target_time_interrupt_enable\
+			invalid callback;returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Register the Callback */
+	ioh_tt_cbptr = callBack;
+
+	/* Set target time interrupt mask */
+	IOH_DEBUG("ioh_1588_target_time_interrupt_enable:invoking\
+			ioh_1588_ttm_imask_set\n");
+	ioh_1588_ttm_imask_set();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_target_time_interrupt_disable(void)
+ *
+ * @brief 	Disable the target time reached/exceeded system time interrupt
+ *
+ * @remarks	This API disables the interrupt that occurs when the System time
+ * 		reaches the Target time set in the IEEE 1588 hardware assist
+ *		 block.
+ * 		The main steps followed in this function are:
+ * 		- Modify Time Sync Control Register to disable target time
+ *		 interrupt
+ * 		- Clear the callback handler
+ *
+ * @param	None
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_target_time_interrupt_disable(void)
+{
+	/* Clear target time interrupt mask */
+	IOH_DEBUG("ioh_1588_target_time_interrupt_disable:invoking \
+			ioh_1588_ttm_imask_clear\n");
+	ioh_1588_ttm_imask_clear();
+
+	/* Unregister the Callback */
+	ioh_tt_cbptr = (ioh1588TargetTimeCallback) NULL;
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_poll(
+ *		unsigned long *ttmPollFlag, struct ioh1588TimeValue *targetTime)
+ *
+ * @brief 	Poll to verify whether the System time is greater or equal
+ * 		to the Target time in the IEEE 1588 hardware assist block.
+ *
+ * @remarks	The main steps followed in this function are:
+ * 		- Validate the parameters and return IOH_1588_INVALIDPARAM, if
+ *		 not valid
+ * 		- If callback function registered, return status
+ *		 IOH_1588_INTERRUPTMODEINUSE
+ * 		- Read the TS_Event register to check for the presence of valid
+ *		 snapshot
+ * 		- Read the TargetTimeSnap low, high registers
+ * 		- Clear the event from TS_Event register
+ *
+ *
+ * @param 	ttmPollFlag 	[OUT] 	TRUE if target time has reached system
+ *					 time
+ *                          		FALSE if target time has not reached
+ *					 system time
+ * @param 	targetTime 	[OUT]  Snap shot of target time captured
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ *      @li IOH_1588_INTERRUPTMODEINUSE - Interrupt mode is in use
+ */
+enum ioh_status
+ioh_1588_target_time_poll(unsigned long *ttmPollFlag,
+			  struct ioh1588TimeValue *targetTime)
+{
+	/* Verify the parameters */
+	if (((unsigned long *)NULL == ttmPollFlag) ||
+	    ((struct ioh1588TimeValue *) NULL == targetTime)) {
+		IOH_LOG(KERN_ERR, "ioh_1588_target_time_poll: invalid param\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Is interrupt mode of processing is enabled? */
+	if ((ioh1588TargetTimeCallback) NULL != ioh_tt_cbptr) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_target_time_poll:returning \
+			IOH_1588_INTERRUPTMODEINUSE\n");
+		return IOH_1588_INTERRUPTMODEINUSE;
+	}
+
+	/* Is the System Time reached or exceeded Target Time? */
+	*ttmPollFlag = ioh_1588_ttm_evt_get();
+	if (FALSE == *ttmPollFlag) {
+		IOH_DEBUG
+		    ("ioh_1588_target_time_poll:target time not reached\n");
+		/* Target Time not to be returned yet */
+		targetTime->timeValueLowWord = 0;
+		targetTime->timeValueHighWord = 0;
+
+		return IOH_1588_SUCCESS;
+	}
+
+	IOH_DEBUG("ioh_1588_target_time_poll:target time reached\n");
+	/* Get the Target Time */
+	ioh_1588_tgt_snap_get(&targetTime->timeValueLowWord,
+			      &targetTime->timeValueHighWord);
+
+	IOH_DEBUG("ioh_1588_target_time_poll:target time:low=%lx high=%lx\n",
+		  targetTime->timeValueLowWord, targetTime->timeValueHighWord);
+
+	IOH_DEBUG
+	    ("ioh_1588_target_time_poll:invoking ioh_1588_ttm_evt_clear\n");
+	/* Clear the target time reached condition (ttipend bit) */
+	ioh_1588_ttm_evt_clear();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_target_time_set(
+ *		struct ioh1588TimeValue targetTime)
+ *
+ * @brief 	Sets the Target Time in the IEEE 1588 hardware assist block
+ *
+ * @remarks 	This API will set the Target Time to a given value.
+ *
+ * @param 	targetTime [IN] - Target time to set
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_target_time_set(struct ioh1588TimeValue targetTime)
+{
+	unsigned long old_mask = FALSE;
+
+	/* Retrieve existing target time interrupt mask value */
+	old_mask = ioh_1588_ttm_imask_get();
+	IOH_DEBUG("ioh_1588_target_time_set:target time interrupt mask=%lx\n",
+		  old_mask);
+
+	/*
+	 * Clear the target time interrupt mask so that the interrupt will not
+	 * come
+	 * during the time we manipulate the registers.
+	 */
+	IOH_DEBUG("ioh_1588_target_time_set:invoking ioh_1588_ttm_imask_clear\
+			to clear the target time interrupt mask\n");
+	ioh_1588_ttm_imask_clear();
+
+	IOH_DEBUG("ioh_1588_target_time_set:invoking ioh_1588_tgt_snap_set \
+		with values:low=%lx,high=%lx\n", \
+		targetTime.timeValueLowWord, targetTime.timeValueHighWord);
+	/* Update Target Time with user specified values */
+	ioh_1588_tgt_snap_set(targetTime.timeValueLowWord,
+			      targetTime.timeValueHighWord);
+
+	/*
+	 * Let the hardware assist re-evaluate the target time reached
+	 * condition based on the new target time
+	 */
+	IOH_DEBUG("ioh_1588_target_time_set:invoking ioh_1588_ttm_evt_clear\n");
+	ioh_1588_ttm_evt_clear();
+
+	/* Restore the preserved target time interrupt mask value */
+	if (TRUE == old_mask) {
+		IOH_DEBUG
+		("ioh_1588_target_time_set:invoking \
+			ioh_1588_ttm_imask_set\n");
+		ioh_1588_ttm_imask_set();
+	}
+
+	IOH_DEBUG("ioh_1588_target_time_set:returning IOH_1588_SUCCESS\n");
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_target_time_get(
+ *		struct ioh1588TimeValue *targetTime)
+ *
+ * @brief 	Gets the Target Time in the IEEE 1588 hardware assist block
+ *
+ * @remarks 	This API will get the Target Time from IEEE 1588 block
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Read and return the content of TargetTime low, high registers
+ *
+ *
+ * @param 	targetTime [IN] - Address to which target time is to be returned
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status ioh_1588_target_time_get(struct ioh1588TimeValue *targetTime)
+{
+	/* Verify the parameter */
+	if ((struct ioh1588TimeValue *) NULL == targetTime) {
+		IOH_DEBUG("ioh_1588_target_time_get:invalid param \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Get Target Time */
+	ioh_1588_tgt_snap_get(&targetTime->timeValueLowWord,
+			      &targetTime->timeValueHighWord);
+	IOH_DEBUG("ioh_1588_target_time_get:invoked ioh_1588_tgt_snap_get \
+		target time:low=%lx,high:%lx\n", \
+		targetTime->timeValueLowWord, targetTime->timeValueHighWord);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_time_interrupt_enable(
+ *		enum ioh1588AuxMode auxMode,ioh1588AuxTimeCallback callBack)
+ *
+ * @brief	Enables the interrupt for the Auxiliary Master/Slave mode for
+ *		 Time
+ * 		Stamp in the IEEE 1588 hardware assist block
+ *
+ * @remarks 	This API will enable the Auxiliary Master/Slave
+ * 		Time stamp Interrupt. The main steps followed in
+ * 		this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Modify the Time Sync Controller register to enable the
+ *		 interrupt
+ * 		- Set the callback routine
+ *
+ *
+ * @param 	auxMode 	[IN] - Auxiliary slave or master mode
+ * @param 	callBack 	[IN] - Callback to be invoked when interrupt
+ *					 fires
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status
+ioh_1588_aux_time_interrupt_enable(enum ioh1588AuxMode auxMode,
+				   ioh1588AuxTimeCallback callBack)
+{
+	/* Verify the parameters */
+	if ((IOH_1588_AUXMODE_INVALID <= auxMode) ||
+	    ((ioh1588AuxTimeCallback) NULL == callBack)) {
+		IOH_DEBUG("ioh_1588_aux_time_interrupt_enable:invalid param \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Register the Callback and SET the amm/asm bits on */
+	if (IOH_1588_AUXMODE_MASTER == auxMode) {
+		IOH_DEBUG
+		("ioh_1588_aux_time_interrupt_enable:IOH_1588_AUXMODE_MASTER \
+			invoking ioh_1588_amms_imask_set\n");
+		ioh_am_cbptr = callBack;
+		ioh_1588_amms_imask_set();
+
+	} else {
+		IOH_DEBUG
+		("ioh_1588_aux_time_interrupt_enable:IOH_1588_AUXMODE_SLAVE \
+			invoking ioh_1588_asms_imask_set\n");
+		ioh_as_cbptr = callBack;
+		ioh_1588_asms_imask_set();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_time_interrupt_disable(
+ *			enum ioh1588AuxMode auxMode)
+ *
+ * @brief 	Disables the interrupt for the Auxiliary Master/Slave mode for
+ *		 Time
+ * 		Stamp in the IEEE 1588 hardware assist block
+ *
+ * @remarks 	This API will disable the Auxiliary Master/Slave
+ * 		Time stamp Interrupt. The main steps followed in this
+ * 		function are:
+ * 		- Return IOH_1588_INVALIDPARAM if auxMode passed is not valid
+ * 		- Modify the Time Sync Controller register to disable the
+ *		 interrupt
+ * 		- Clear the callback handler
+ *
+ *
+ * @param 	auxMode [IN] - Auxiliary slave or master mode
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid mode specified
+ */
+enum ioh_status ioh_1588_aux_time_interrupt_disable(enum ioh1588AuxMode auxMode)
+{
+	/* Verify the parameters */
+	if (IOH_1588_AUXMODE_INVALID <= auxMode) {
+		IOH_DEBUG("ioh_1588_aux_time_interrupt_disable:invalid param \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	if (IOH_1588_AUXMODE_MASTER == auxMode) {
+		IOH_DEBUG
+		    ("ioh_1588_aux_time_interrupt_disable:\
+			IOH_1588_AUXMODE_MASTER\
+			invoking ioh_1588_amms_imask_clear\n");
+		ioh_1588_amms_imask_clear();
+		ioh_am_cbptr = (ioh1588AuxTimeCallback) NULL;
+	} else {
+		IOH_DEBUG
+		    ("ioh_1588_aux_time_interrupt_disable:\
+			IOH_1588_AUXMODE_SLAVE\
+			invoking ioh_1588_asms_imask_clear\n");
+		ioh_1588_asms_imask_clear();
+		ioh_as_cbptr = (ioh1588AuxTimeCallback) NULL;
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_time_poll(
+ *		enum ioh1588AuxMode auxMode, unsigned long *pollFlag,
+ *		struct ioh1588TimeValue*auxTime)
+ *
+ * @brief 	Poll for the Auxiliary Time Stamp captured event for the mode
+ *		 requested
+ *
+ * @remarks 	Polls for the Time stamp in the appropriate Auxiliary Snapshot
+ * 		Registers based on the mode specified. Return true and
+ * 		the contents of the Auxiliary snapshot if it is available
+ * 		otherwise return false. The main steps followed in this function
+ * 		are:
+ * 		- Validate the parameters and return IOH_1588_INVALIDPARAM if
+ *		 found invalid
+ * 		- If callbacks registered, return status
+ *		 IOH_1588_INTERRUPTMODEINUSE
+ * 		- Read the TS_Event register to check for the presence of valid
+ *		 snapshot
+ * 		- If the event is not set, return status IOH_1588_NOTIMESTAMP
+ * 		- Read the AuxSlaveModeSnap or AuxMasterModeSnap low, high
+ *		 registers depending on the auxMode
+ * 		- Clear the event from TS_Event register
+ *
+ *
+ * @param 	auxMode 	[IN]  	Auxiliary Snapshot Register
+ *					 (Master/Slave) to be checked
+ * @param 	pollFlag 	[OUT]  	TRUE if time stamp captured in aux
+ *					 snapshot register
+ *                          		FALSE if the time stamp not captured
+ * @param 	auxTime 	[OUT]  	Buffer for returning captured Auxiliary
+ *					 Snapshot time
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameter passed
+ *      @li IOH_1588_INTERRUPTMODEINUSE - Interrupt mode is in use
+ */
+enum ioh_status
+ioh_1588_aux_time_poll(enum ioh1588AuxMode auxMode, unsigned long *pollFlag,
+		       struct ioh1588TimeValue *auxTime)
+{
+	unsigned long ammsFlag = FALSE;
+	unsigned long asmsFlag = FALSE;
+
+	/* Verify the parameters */
+	if (((unsigned long *)NULL == pollFlag) ||
+	    (IOH_1588_AUXMODE_INVALID <= auxMode) ||
+	    ((struct ioh1588TimeValue *) NULL == auxTime)) {
+		IOH_DEBUG("ioh_1588_aux_time_poll:invalid param \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Get Auxiliary Master/Slave Mode Snapshot */
+	if (IOH_1588_AUXMODE_MASTER == auxMode) {
+		IOH_DEBUG("ioh_1588_aux_time_poll:IOH_1588_AUXMODE_MASTER\n");
+		/* Is interrupt mode of processing is enabled? */
+		if ((ioh1588AuxTimeCallback) NULL != ioh_am_cbptr) {
+			IOH_DEBUG
+			    ("ioh_1588_aux_time_poll:interrupt mode in use\n");
+			return IOH_1588_INTERRUPTMODEINUSE;
+		}
+
+		/* Is the Auxiliary Master Mode Snapshot available? */
+		ammsFlag = ioh_1588_amms_evt_get();
+		if (FALSE == ammsFlag) {
+			IOH_DEBUG("ioh_1588_aux_time_poll:NO Auxiliary Master \
+				Mode Snapshot available\n");
+			*pollFlag = FALSE;
+			auxTime->timeValueLowWord = 0;
+			auxTime->timeValueHighWord = 0;
+			return IOH_1588_SUCCESS;
+		}
+
+		/* Get Auxiliary Master Snapshot */
+		ioh_1588_aux_master_snap_get(&auxTime->timeValueLowWord,
+					     &auxTime->timeValueHighWord);
+		IOH_DEBUG("ioh_1588_aux_time_poll:Auxiliary Master Snapshot \
+			low=%lx,high=%lx\n", auxTime->timeValueLowWord, \
+			auxTime->timeValueHighWord);
+
+		*pollFlag = TRUE;
+
+		/* Clear the snapshot availability condition */
+		IOH_DEBUG
+		("ioh_1588_aux_time_poll:invoking ioh_1588_amms_evt_clear\n");
+		ioh_1588_amms_evt_clear();
+	} else {		/* IOH_1588_AUXMODE_SLAVE == auxMode */
+
+		IOH_DEBUG("ioh_1588_aux_time_poll:IOH_1588_AUXMODE_SLAVE\n");
+		/* Is interrupt mode of processing is enabled? */
+		if ((ioh1588AuxTimeCallback) NULL != ioh_as_cbptr) {
+			IOH_DEBUG
+			    ("ioh_1588_aux_time_poll:interrupt mode in use\n");
+			return IOH_1588_INTERRUPTMODEINUSE;
+		}
+
+		/* Is the Auxiliary Slave Mode Snapshot available? */
+		asmsFlag = ioh_1588_asms_evt_get();
+		if (FALSE == asmsFlag) {
+			IOH_DEBUG("ioh_1588_aux_time_poll:NO Auxiliary Slave \
+				Mode Snapshot available\n");
+			*pollFlag = FALSE;
+			auxTime->timeValueLowWord = 0;
+			auxTime->timeValueHighWord = 0;
+			return IOH_1588_SUCCESS;
+		}
+
+		/* Get Auxiliary Slave Snapshot */
+		ioh_1588_aux_slave_snap_get(&auxTime->timeValueLowWord,
+					    &auxTime->timeValueHighWord);
+		IOH_DEBUG("ioh_1588_aux_time_poll:Auxiliary Slave Snapshot \
+		low=%lx,high=%lx\n", auxTime->timeValueLowWord, \
+		auxTime->timeValueHighWord);
+
+		*pollFlag = TRUE;
+
+		/* Clear the snapshot availability condition */
+		IOH_DEBUG
+		("ioh_1588_aux_time_poll:invoking ioh_1588_amms_evt_clear\n");
+		ioh_1588_asms_evt_clear();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_reset(void)
+ *
+ * @brief 	Resets the IEEE 1588 hardware assist block
+ *
+ * @remarks 	Resets the IEEE 1588 hardware assist block. The
+ * 		main steps followed in this function are:
+ * 		- Set the reset bit of Time Sync Control register
+ * 		- Clear the reset bit of Time Sync Control register
+ *      -Note: For A0/A1 sample, test mode setting is enabled for
+ *       the 64 bit System Time Register. This is a work around for
+ *       the non continuous value in the 64 bit System Time Register
+ *       consisting of High(32bit) / Low(32bit)
+ *
+ *
+ * @param 	None
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation is successful
+ */
+enum ioh_status ioh_1588_reset(void)
+{
+	/* Reset Hardware Assist */
+	IOH_DEBUG("ioh_1588_reset:invoking ioh_1588_block_reset\n");
+	ioh_1588_block_reset();
+
+	/* Clear Stats */
+	ioh_1588_stats.rxMsgs = ioh_1588_stats.txMsgs = 0;
+
+	/* Unregister any Callback Routines */
+	IOH_DEBUG("ioh_1588_reset:unregistering callbacks\n");
+	ioh_pps_cbptr = (ioh1588PulsePerSecondCallback) NULL;
+	ioh_am_cbptr = (ioh1588AuxTimeCallback) NULL;
+	ioh_as_cbptr = (ioh1588AuxTimeCallback) NULL;
+	ioh_tt_cbptr = (ioh1588TargetTimeCallback) NULL;
+
+#ifdef IOH_IEEE1588_A0_A1_SAMPLE_BUG
+	/*enable all 32 bits in system time registers */
+	ioh_1588_set_system_time_count();
+#endif
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_chnl_reset(enum ioh1588PTPPort ptpPort)
+ *
+ * @brief 	Resets the IEEE 1588 channel by resetting the hardware block
+ *
+ * @remarks 	This API also sets the reset bit in the IEEE1588 to fully
+ * 		resets the block. The main steps followed in this function
+ * 		are:
+ * 		- Return IOH_1588_INVALIDPARAM if ptpPort passed is not valid
+ * 		- Perform a block level reset by invoking ioh_1588_reset
+ *
+ *
+ * @param 	ptpPort	[IN]  	The PTP port that is to be reset
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_chnl_reset(enum ioh1588PTPPort ptpPort)
+{
+	IOH_DEBUG("ioh_1588_chnl_reset:invoking ioh_1588_reset\n");
+	return ioh_1588_reset();
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_stats_get(struct ioh1588Stats *stats)
+ *
+ * @brief 	Returns the ioh1588 Statistics
+ *
+ * @remarks 	This API will return the statistics of the snapshots captured
+ *		 for
+ * 		receive and transmit of messages. The main steps followed in
+ *		 this
+ *		function are:
+ *		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ *		- Return the counter values stored for Rx and Tx messages
+ *
+ *
+ * @param 	stats		[OUT]  	Buffer for returning the statistics
+ *					 counter values
+ *
+ *
+ * @note 	These counters are updated only when the client application
+ *		 polls for
+ * 		the time stamps or interrupt are enabled.
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation is successful
+ *      @li IOH_1588_INVALIDPARAM - NULL parameter passed
+ */
+
+enum ioh_status ioh_1588_stats_get(struct ioh1588Stats *stats)
+{
+	/* Verify the parameter */
+	if ((struct ioh1588Stats *) NULL == stats) {
+		IOH_DEBUG("ioh_1588_stats_get:invalid param \
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Return the statistics */
+	stats->rxMsgs = ioh_1588_stats.rxMsgs;
+	stats->txMsgs = ioh_1588_stats.txMsgs;
+	IOH_DEBUG("ioh_1588_stats_get:stats-txMsg=%lx,rxMsg=%lx\n",
+		  stats->txMsgs, stats->rxMsgs);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		void ioh_1588_stats_reset(void)
+ *
+ * @brief 	Resets the statistics counters
+ *
+ * @remarks 	This API will reset the statistics counters maintained by the
+ *		 driver
+ *
+ * @param 	None
+ * @retval 	None
+ */
+void ioh_1588_stats_reset(void)
+{
+	/* Clear the statistics */
+	IOH_DEBUG("ioh_1588_stats_reset:clearing stats\n");
+	ioh_1588_stats.rxMsgs = ioh_1588_stats.txMsgs = 0;
+
+	return;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		void ioh_1588_save_state(void)
+ *
+ * @brief 	Save the state of all registers
+ *
+ * @remarks 	Save the content of all registers of IEEE1588 module
+ *
+ * @param 	None.
+ *
+ * @retval  	None
+ */
+void ioh_1588_save_state(void)
+{
+	int i;
+	unsigned long val;
+
+	/* Time stamp control register */
+	ioh_1588_regs.ts_control =
+	    (ioh_1588_ttm_imask_get() << IOH_1588_TSC_TTM_SHIFT) |
+	    (ioh_1588_asms_imask_get() << IOH_1588_TSC_ASMS_SHIFT) |
+	    (ioh_1588_amms_imask_get() << IOH_1588_TSC_AMMS_SHIFT) |
+	    (ioh_1588_pps_imask_get() << IOH_1588_TSC_PPSM_SHIFT);
+	IOH_DEBUG("ioh_1588_save_state:TS_CONTROL reg=%lx\n",
+		  ioh_1588_regs.ts_control);
+
+	/*
+	 * Time stamp event register; clear on write,
+	 * so no point in reading and then saving;
+	 * Will be cleared on restore to start in a clean slate
+	 */
+	ioh_1588_regs.ts_event = IOH_1588_TSE_TTIPEND | IOH_1588_TSE_SNS |
+	    IOH_1588_TSE_SNM | IOH_1588_TSE_PPS;
+	IOH_DEBUG("ioh_1588_save_state:TS_EVENT reg=%lx\n",
+		  ioh_1588_regs.ts_event);
+
+	/* Addend register */
+	ioh_1588_addend_get(&ioh_1588_regs.ts_addend);
+	IOH_DEBUG("ioh_1588_save_state:TS_ADDEND reg=%lx\n",
+		  ioh_1588_regs.ts_addend);
+
+	/* PPS comapre register */
+	ioh_1588_pps_get(&ioh_1588_regs.ts_compare);
+	IOH_DEBUG("ioh_1588_save_state:TS_COMPARE reg=%lx\n",
+		  ioh_1588_regs.ts_compare);
+
+	/* System time Low and Hi registers */
+	ioh_1588_sys_snap_get(&ioh_1588_regs.ts_syslo, &ioh_1588_regs.ts_syshi);
+	IOH_DEBUG("ioh_1588_save_state:sys time reg-low =%lx,high=%lx\n",
+		  ioh_1588_regs.ts_syslo, ioh_1588_regs.ts_syshi);
+
+	/* Target time Low and Hi registers */
+	ioh_1588_tgt_snap_get(&ioh_1588_regs.ts_tgtlo, &ioh_1588_regs.ts_tgthi);
+	IOH_DEBUG("ioh_1588_save_state:target time reg-low =%lx,high=%lx\n",
+		  ioh_1588_regs.ts_tgtlo, ioh_1588_regs.ts_tgthi);
+
+#if 0
+	/*
+	 * Below registers are read only, so no point in reading/storing, since
+	 * we can't restore them
+	 */
+	/* Slave mode snapshot Low and Hi registers */
+	ioh_1588_aux_slave_snap_get(&ioh_1588_regs.ts_asmslo,
+				    &ioh_1588_regs.ts_asmshi);
+
+	/* Master mode snapshot Low and Hi registers */
+	ioh_1588_aux_master_snap_get(&ioh_1588_regs.ts_ammslo,
+				     &ioh_1588_regs.ts_ammshi);
+#endif
+	ioh_1588_regs.ts_cc =
+	    (ioh_1588_master_mode_get() << IOH_1588_CC_MM_SHIFT) |
+	    (ioh_1588_timestamp_all_get() << IOH_1588_CC_TA_SHIFT) |
+	    (ioh_1588_op_mode_get() << IOH_1588_CC_MODE_SHIFT) |
+	    (ioh_1588_version_get() << IOH_1588_CC_VERSION_SHIFT);
+	IOH_DEBUG("ioh_1588_save_state:TS_CC reg=%lx\n", ioh_1588_regs.ts_cc);
+
+	/* Channel event register, not saved - will be cleared on restore */
+	ioh_1588_regs.ts_ce = IOH_1588_CE_TXS | IOH_1588_CE_RXS;
+
+#if 0
+	/*
+	 * Below registers are read only, so no point in reading/storing, since
+	 * we can't restore them
+	 */
+	ioh_1588_rx_snap_get(&ioh_1588_regs.ts_xslo, &ioh_1588_regs.ts_xshi);
+	ioh_1588_tx_snap_get(&ioh_1588_regs.ts_rslo, &ioh_1588_regs.ts_rshi);
+	ioh_1588_uuid_seqid_get(&ioh_1588_regs.ts_uuidlo,
+				&ioh_1588_regs.ts_uuidhi);
+
+	/* CAN */
+	ioh_1588_can_snap_get(&ioh_1588_regs.ts_cxslo, &ioh_1588_regs.ts_cxshi);
+#endif
+
+	/* CAN Channel event register, not saved - will be cleared on restore */
+	ioh_1588_regs.ts_cce = IOH_1588_CE_OVR | IOH_1588_CE_VAL;
+
+	/* Ethernet CAN selector register */
+	ioh_1588_regs.ts_sel =
+	    (ioh_1588_eth_enable_get() << IOH_1588_ECS_ETH_SHIFT) |
+	    (ioh_1588_can_enable_get() << IOH_1588_ECS_CAN_SHIFT);
+	IOH_DEBUG("ioh_1588_save_state:TS_SEL reg=%lx\n", ioh_1588_regs.ts_sel);
+
+	/* Station Address registers */
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {
+		ioh_1588_station_get(i, &val);
+		ioh_1588_regs.ts_sti[i] = val & 0xff;
+		IOH_DEBUG("ioh_1588_save_state:TS_ST[%d] reg=%d\n", i,
+			  ioh_1588_regs.ts_sti[i]);
+	}
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		void ioh_1588_restore_state(void)
+ *
+ * @brief 	Restore the state of all registers
+ *
+ * @remarks 	Restores the content of all registers of IEEE1588 module.
+ *              Note: For A0/A1 sample, test mode setting is enabled for
+ *              the 64 bit System Time Register. This is a work around for
+ *       		the non continuous value in the 64 bit System Time
+ *			 Register
+ *       		consisting of High(32bit) / Low(32bit)
+ *
+ * @param	None
+ * @retval 	None
+ */
+void ioh_1588_restore_state(void)
+{
+	int i;
+
+	/* Time stamp control register */
+	if (ioh_1588_regs.ts_control & IOH_1588_TSC_TTM_MASK) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_ttm_imask_set\n");
+		ioh_1588_ttm_imask_set();
+	}
+	if (ioh_1588_regs.ts_control & IOH_1588_TSC_ASMS_MASK) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_asms_imask_set\n");
+		ioh_1588_asms_imask_set();
+	}
+	if (ioh_1588_regs.ts_control & IOH_1588_TSC_AMMS_MASK) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_amms_imask_set\n");
+		ioh_1588_amms_imask_set();
+	}
+	if (ioh_1588_regs.ts_control & IOH_1588_TSC_PPSM_MASK) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_pps_imask_set\n");
+		ioh_1588_pps_imask_set();
+	}
+
+	/* Time stamp event register; clear all events */
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_ttm_evt_clear\n");
+	ioh_1588_ttm_evt_clear();
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_asms_evt_clear\n");
+	ioh_1588_asms_evt_clear();
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_amms_evt_clear\n");
+	ioh_1588_amms_evt_clear();
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_pps_evt_clear\n");
+	ioh_1588_pps_evt_clear();
+
+#ifdef IOH_IEEE1588_A0_A1_SAMPLE_BUG
+	/*enable all 32 bits in system time registers */
+	ioh_1588_set_system_time_count();
+#endif
+
+	/* Addend register */
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_addend_set\n");
+	ioh_1588_addend_set(ioh_1588_regs.ts_addend);
+
+	/* PPS comapre register */
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_pps_set\n");
+	ioh_1588_pps_set(ioh_1588_regs.ts_compare);
+
+	/* System time Low and Hi registers */
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_sys_snap_set\n");
+	ioh_1588_sys_snap_set(ioh_1588_regs.ts_syslo, ioh_1588_regs.ts_syshi);
+
+	/* Target time Low and Hi registers */
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_tgt_snap_set\n");
+	ioh_1588_tgt_snap_set(ioh_1588_regs.ts_tgtlo, ioh_1588_regs.ts_tgthi);
+
+	/* Ethernet Channel Control register */
+	if (ioh_1588_regs.ts_cc & IOH_1588_CC_MM) {
+		IOH_DEBUG
+		    ("ioh_1588_restore_state:invoking ioh_1588_master_mode_set\
+				with TRUE as parameter\n");
+		ioh_1588_master_mode_set(TRUE);
+	}
+	if (ioh_1588_regs.ts_cc & IOH_1588_CC_TA) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_timestamp_all_set\
+				with TRUE as parameter\n");
+		ioh_1588_timestamp_all_set(TRUE);
+	}
+	IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_op_mode_set\n");
+	ioh_1588_op_mode_set((ioh_1588_regs.ts_cc & IOH_1588_CC_MODE_MASK) >>
+			     IOH_1588_CC_MODE_SHIFT);
+	if (ioh_1588_regs.ts_cc & IOH_1588_CC_VERSION) {
+		IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_version_set\
+				with IOH_1588PTP_VERSION_1 as parameter\n");
+		ioh_1588_version_set(IOH_1588PTP_VERSION_1);
+	}
+
+	/* Channel event register, cleared on restore */
+	IOH_DEBUG
+	    ("ioh_1588_restore_state:invoking ioh_1588_rx_snap_evt_clear\n");
+	ioh_1588_rx_snap_evt_clear();
+	IOH_DEBUG
+	    ("ioh_1588_restore_state:invoking ioh_1588_tx_snap_evt_clear\n");
+	ioh_1588_tx_snap_evt_clear();
+
+	/* CAN Channel event register, cleared on restore */
+	IOH_DEBUG
+	    ("ioh_1588_restore_state:invoking ioh_1588_tx_snap_ovr_clear\n");
+	ioh_1588_can_snap_ovr_clear();
+	IOH_DEBUG
+	    ("ioh_1588_restore_state:invoking ioh_1588_tx_snap_valid_clear\n");
+	ioh_1588_can_snap_valid_clear();
+
+	/* Ethernet CAN selector register */
+	if (ioh_1588_regs.ts_sel & IOH_1588_ECS_ETH) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_eth_enable_set\n");
+		ioh_1588_eth_enable_set();
+	}
+	if (ioh_1588_regs.ts_sel & IOH_1588_ECS_CAN) {
+		IOH_DEBUG
+		("ioh_1588_restore_state:invoking ioh_1588_can_enable_set\n");
+		ioh_1588_can_enable_set();
+	}
+
+	/* Station Address registers */
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {
+		IOH_DEBUG("ioh_1588_restore_state:invoking ioh_1588_station_set\
+				for station=%d\n", i);
+		ioh_1588_station_set(i, ioh_1588_regs.ts_sti[i]);
+	}
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		void ioh_1588_show(void)
+ *
+ * @brief 	Display the dump of IEEE 1588 registers
+ *
+ * @remarks 	This API will dump the contents of configuration, event and
+ *		 snapshot
+ * 		registers of the IEEE1588 module
+ *
+ * @param	None.
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS
+ */
+enum ioh_status ioh_1588_show(void)
+{
+	int i;
+	unsigned long flag = FALSE;
+	unsigned long reg_low = 0;
+	unsigned long reg_hi = 0;
+	unsigned int seq_id = 0;
+	unsigned long uuid_low = 0;
+	unsigned long uuid_hi = 0;
+
+	/*dump all register as such */
+	IOH_DEBUG("TS Control Register offset = %x,content = %x\n",
+		  IOH_1588_TSC_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_TSC_OFFSET));
+	IOH_DEBUG("TS Event Register offset = %x,content = %x\n",
+		  IOH_1588_TSE_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_TSE_OFFSET));
+	IOH_DEBUG("TS Addend Register offset = %x,content = %x\n",
+		  IOH_1588_ADD_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_ADD_OFFSET));
+	IOH_DEBUG("TS Accumulator Register offset = %x,content =  %x\n",
+		  IOH_1588_ACC_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_ACC_OFFSET));
+	IOH_DEBUG("TS Test Register offset = %x,content = %x\n",
+		  IOH_1588_TST_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_TST_OFFSET));
+	IOH_DEBUG("TS PPS Compare Register offset = %x,content = %x\n",
+		  IOH_1588_PPS_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_PPS_OFFSET));
+	IOH_DEBUG("TS System Time Low Register offset = %x,content = %x\n",
+		  IOH_1588_STL_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_STL_OFFSET));
+	IOH_DEBUG("TS System Time High Register offset = %x,content = %x\n",
+		  IOH_1588_STH_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_STH_OFFSET));
+	IOH_DEBUG("TS Target Time Low Register offset = %x,content = %x\n",
+		  IOH_1588_TTL_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_TTL_OFFSET));
+	IOH_DEBUG("TS Target Time High Register offset = %x,content = %x\n",
+		  IOH_1588_TTH_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_TTH_OFFSET));
+	IOH_DEBUG
+	("TS Aux Slave Mode Snapshot Low Register offset = %x,content = %x\n",
+		IOH_1588_ASSL_OFFSET,
+		IOH_READ32(ioh_1588_base + IOH_1588_ASSL_OFFSET));
+	IOH_DEBUG
+	("TS Aux Slave Mode Snapshot High Register offset = %x,content = %x\n",
+	     IOH_1588_ASSH_OFFSET,
+	     IOH_READ32(ioh_1588_base + IOH_1588_ASSH_OFFSET));
+	IOH_DEBUG
+	("TS Aux Master Mode Snapshot Low Register offset = %x,content = %x\n",
+	     IOH_1588_AMSL_OFFSET,
+	     IOH_READ32(ioh_1588_base + IOH_1588_AMSL_OFFSET));
+	IOH_DEBUG
+	("TS Aux Master Mode Snapshot High Register offset = %x,content = %x\n",
+	     IOH_1588_AMSH_OFFSET,
+	     IOH_READ32(ioh_1588_base + IOH_1588_AMSH_OFFSET));
+	IOH_DEBUG("TS Channel Control Register offset = %x,content = %x\n",
+		  IOH_1588_CC_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_CC_OFFSET));
+	IOH_DEBUG("TS Channel Event Register offset = %x,content = %x\n",
+		  IOH_1588_CE_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_CE_OFFSET));
+	IOH_DEBUG("TS Tx Snapshot High Register offset = %x,content = %x\n",
+		  IOH_1588_XSH_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_XSH_OFFSET));
+	IOH_DEBUG("TS Tx Snapshot Low Register offset = %x,content = %x\n",
+		  IOH_1588_XSL_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_XSL_OFFSET));
+	IOH_DEBUG("TS Rx Snapshot Low Register offset = %x,content = %x\n",
+		  IOH_1588_RSL_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_RSL_OFFSET));
+	IOH_DEBUG("TS Rx Snapshot High Register offset = %x,content = %x\n",
+		  IOH_1588_RSH_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_RSH_OFFSET));
+	IOH_DEBUG("TS Source UUID Low Register offset = %x,content = %x\n",
+		  IOH_1588_UID_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_UID_OFFSET));
+	IOH_DEBUG
+	("TS Source UUID High/SequenceID Register offset = %x,content = %x\n",
+	     IOH_1588_SID_OFFSET,
+	     IOH_READ32(ioh_1588_base + IOH_1588_SID_OFFSET));
+	IOH_DEBUG("TS CAN Channel Status Register offset = %x,content = %x\n",
+		  IOH_1588_CCE_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_CCE_OFFSET));
+	IOH_DEBUG("TS CAN Snapshot Low Register offset = %x,content = %x\n",
+		  IOH_1588_CXSL_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_CXSL_OFFSET));
+	IOH_DEBUG("TS CAN Snapshot High Register offset = %x,content = %x\n",
+		  IOH_1588_CXSH_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_CXSH_OFFSET));
+	IOH_DEBUG("TS Ethernet/CAN Selecti Register offset = %x,content = %x\n",
+		  IOH_1588_ECS_OFFSET,
+		  IOH_READ32(ioh_1588_base + IOH_1588_ECS_OFFSET));
+	/* Station Address registers */
+	IOH_DEBUG("TS Station Address [1-6]");
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {
+		ioh_1588_station_get(i, &reg_low);
+		IOH_DEBUG(":%02lx", reg_low);
+	}
+	IOH_DEBUG("\n");
+
+	/* Target time reached interrupt mask */
+	flag = ioh_1588_ttm_imask_get();
+	IOH_LOG(KERN_ERR, "Target Time Interrupt Mask: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Auxiliary Slave Mode Snapshot interrupt mask  */
+	flag = ioh_1588_asms_imask_get();
+	IOH_LOG(KERN_ERR, "ASMS Interrupt Mask: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Auxiliary Master Mode Snapshot interrupt mask */
+	flag = ioh_1588_amms_imask_get();
+	IOH_LOG(KERN_ERR, "AMMS Interrupt Mask: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Pulse per second interrupt mask */
+	flag = ioh_1588_pps_imask_get();
+	IOH_LOG(KERN_ERR, "PPS Interrupt Mask: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* TS_Event Register */
+	/* Target time interrupt event */
+	flag = ioh_1588_ttm_evt_get();
+	IOH_LOG(KERN_ERR, "Target Time Interrupt Pending: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Auxiliary Slave Mode Snapshot event  */
+	flag = ioh_1588_asms_evt_get();
+	IOH_LOG(KERN_ERR, "ASMS Snapshot Event: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Auxiliary Master Mode Snapshot event */
+	flag = ioh_1588_amms_evt_get();
+	IOH_LOG(KERN_ERR, "AMMS Snapshot Event: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* PPS Match event */
+	flag = ioh_1588_pps_evt_get();
+	IOH_LOG(KERN_ERR, "PPS Match Event: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Addend Register */
+	reg_low = 0;
+	ioh_1588_addend_get(&reg_low);
+	IOH_LOG(KERN_ERR, "Frequency Scaling Value: %lx\n", reg_low);
+
+	/* PPS Comapre Register */
+	reg_low = 0;
+	ioh_1588_pps_get(&reg_low);
+	IOH_LOG(KERN_ERR, "PPS Compare Register Value: %lx\n", reg_low);
+
+	/* System Time registers */
+	reg_low = reg_hi = 0;
+	ioh_1588_sys_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR, "System Time (Hi:Low): %lx : %lx\n", reg_hi, reg_low);
+
+	/* Target Time registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_tgt_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR, "Target Time (Hi:Low): %lx : %lx\n", reg_hi, reg_low);
+
+	/* Auxiliary Slave Mode Snapshot registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_aux_slave_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR,
+		"Auxiliary Slave Mode Snapshot (Hi:Low) : %lx : %lx\n", reg_hi,
+		reg_low);
+
+	/* Auxiliary Master Mode Snapshot registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_aux_master_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR,
+		"Auxiliary Master Mode Snapshot (Hi:Low): %lx : %lx\n", reg_hi,
+		reg_low);
+
+	/* Ethernet port */
+	IOH_LOG(KERN_ERR, "\nPTP Eth Port\n");
+
+	/* Master Mode */
+	flag = ioh_1588_master_mode_get();
+	IOH_LOG(KERN_ERR, "Master Mode: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Timestamp All PTP messages */
+	flag = ioh_1588_timestamp_all_get();
+	IOH_LOG(KERN_ERR, "Timestamp All Messages: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Version */
+	flag = ioh_1588_version_get();
+	IOH_LOG(KERN_ERR, "Version support: %s\n",
+		((TRUE == flag) ? "v1 and v2" : "v1 only"));
+
+	/* Receive Snapshot Locked  */
+	flag = ioh_1588_rx_snap_evt();
+	IOH_LOG(KERN_ERR, "Receive Snapshot Locked: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Transmit Snapshot Locked  */
+	flag = ioh_1588_tx_snap_evt();
+	IOH_LOG(KERN_ERR, "Transmit Snapshot Locked: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Receive Snapshot registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_rx_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR, "Receive Snapshot (Hi:Low): %lx : %lx\n", reg_hi,
+		reg_low);
+
+	/* Transmit Snapshot registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_tx_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR, "Transmit Snapshot (Hi:Low): %lx : %lx\n", reg_hi,
+		reg_low);
+
+	/* UUID and Seqquence Id  */
+	ioh_1588_uuid_seqid_get(&uuid_low, &uuid_hi, &seq_id);
+	IOH_LOG(KERN_ERR, "UUID (Hi:Lo): %lx : %lx\n", uuid_hi, uuid_low);
+	IOH_LOG(KERN_ERR, "Sequence id: %x\n", seq_id);
+
+	/* CAN port  */
+	IOH_LOG(KERN_ERR, "\nPTP CAN Port:\n");
+
+	/* Snapshot Valid */
+	flag = ioh_1588_can_snap_valid();
+	IOH_LOG(KERN_ERR, "Snapshot Valid : %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Snapshot Overrun */
+	flag = ioh_1588_can_snap_ovr();
+	IOH_LOG(KERN_ERR, "Snapshot Overrun: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* CAN Snapshot registers  */
+	reg_low = reg_hi = 0;
+	ioh_1588_can_snap_get(&reg_low, &reg_hi);
+	IOH_LOG(KERN_ERR, "CAN Snapshot (Hi:Low): %lx : %lx\n", reg_hi,
+		reg_low);
+
+	/* Ethernet Selector */
+	flag = ioh_1588_eth_enable_get();
+	IOH_LOG(KERN_ERR, "\nEthernet Enable: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* CAN Selector */
+	flag = ioh_1588_can_enable_get();
+	IOH_LOG(KERN_ERR, "CAN Enable: %s\n",
+		((TRUE == flag) ? "Set" : "Clear"));
+
+	/* Station Address Registers */
+	IOH_LOG(KERN_ERR, "Station Address [1-6]");
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {
+		ioh_1588_station_get(i, &reg_low);
+		IOH_LOG(KERN_ERR, ":%02lx", reg_low);
+	}
+	IOH_LOG(KERN_ERR, "\n");
+
+	/* Statistics  */
+	IOH_LOG(KERN_ERR,
+		"Receive Snapshot Count: %lu\nTransmit Snapshot Count: %lu\n",
+		ioh_1588_stats.rxMsgs, ioh_1588_stats.txMsgs);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_can_poll (
+ *		enum ioh1588PTPPort ptpPort,
+ *		struct ioh1588TimeValue *ptpTimeStamp)
+ *
+ * @brief 	Polls the IEEE 1588 message time stamp detect status on a given
+ *		 CAN PTP Port.
+ *
+ * @remarks 	This API polls for the availability of a time stamp on a CAN
+ *		 port.
+ *
+ * @param 	ptpPort 	[IN]  	PTP port to poll
+ * @param 	ptpTimeStamp 	[OUT]  	Buffer to store the snapshot captured
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ *      @li IOH_1588_NOTIMESTAMP - No time stamp available
+ */
+enum ioh_status
+ioh_1588_ptp_can_poll(enum ioh1588PTPPort ptpPort, \
+			struct ioh1588TimeValue *ptpTimeStamp)
+{
+	unsigned long valid = FALSE;
+	unsigned long overrun = FALSE;
+
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_CAN_0_1588PTP_PORT) ||
+	    ((struct ioh1588TimeValue *) NULL == ptpTimeStamp)) {
+		IOH_DEBUG("ioh_1588_ptp_can_poll:invalid params\
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Check whether a new timestamp available? */
+	IOH_DEBUG("ioh_1588_ptp_can_poll:invoking ioh_1588_can_snap_valid\n");
+	valid = ioh_1588_can_snap_valid();
+
+	/* there is not a valid timestamp */
+	if (TRUE != valid) {
+		IOH_DEBUG("ioh_1588_ptp_can_poll:no valid timestamp\
+			returning IOH_1588_NOTIMESTAMP\n");
+		return IOH_1588_NOTIMESTAMP;
+	}
+
+	/* check overrun bit before retreiving timestamp */
+	IOH_DEBUG("ioh_1588_ptp_can_poll:invoking ioh_1588_can_snap_ovr\n");
+	overrun = ioh_1588_can_snap_ovr();
+
+	/* if the timestamp has been overwritten */
+	if (TRUE == overrun) {
+		IOH_DEBUG("ioh_1588_ptp_can_poll:overrun occured\n");
+		/* reset valid and overrun bits */
+		IOH_DEBUG
+		("ioh_1588_ptp_can_poll:invoking \
+			ioh_1588_can_snap_valid_clear\n");
+		ioh_1588_can_snap_valid_clear();
+		IOH_DEBUG
+		("ioh_1588_ptp_can_poll:invoking \
+			ioh_1588_can_snap_ovr_clear\n");
+		ioh_1588_can_snap_ovr_clear();
+
+		/* return no valid timestamp available */
+		ptpTimeStamp->timeValueLowWord = 0;
+		ptpTimeStamp->timeValueHighWord = 0;
+
+		IOH_DEBUG
+		    ("ioh_1588_ptp_can_poll:returning IOH_1588_NOTIMESTAMP\n");
+		return IOH_1588_NOTIMESTAMP;
+	}
+
+	/* Fetch the receive timestamp */
+	ioh_1588_can_snap_get(&ptpTimeStamp->timeValueLowWord,
+			      &ptpTimeStamp->timeValueHighWord);
+	IOH_DEBUG("ioh_1588_ptp_can_poll:timestamp-low=%lx,high=%lx\n",
+		  ptpTimeStamp->timeValueLowWord,
+		  ptpTimeStamp->timeValueHighWord);
+
+	/* check overrun bit again to ensure timestamp is valid */
+	overrun = ioh_1588_can_snap_ovr();
+
+	/* if the timestamp has been overwritten */
+	if (TRUE == overrun) {
+		IOH_DEBUG("ioh_1588_ptp_can_poll:overrun occured\n");
+		/* reset valid and overrun bits */
+		IOH_DEBUG
+		("ioh_1588_ptp_can_poll:invoking \
+			ioh_1588_can_snap_valid_clear\n");
+		ioh_1588_can_snap_valid_clear();
+		IOH_DEBUG
+		("ioh_1588_ptp_can_poll:invoking \
+			ioh_1588_can_snap_ovr_clear\n");
+		ioh_1588_can_snap_ovr_clear();
+
+		/* return no valid timestamp available */
+		ptpTimeStamp->timeValueLowWord = 0;
+		ptpTimeStamp->timeValueHighWord = 0;
+
+		IOH_DEBUG
+		    ("ioh_1588_ptp_can_poll:returning IOH_1588_NOTIMESTAMP\n");
+		return IOH_1588_NOTIMESTAMP;
+	}
+
+	/* reset valid bit */
+	IOH_DEBUG
+	    ("ioh_1588_ptp_can_poll:invoking ioh_1588_can_snap_valid_clear\n");
+	ioh_1588_can_snap_valid_clear();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_handler(void)
+ *
+ * @brief 	Interrupt handler for the IEEE 1588 module
+ *
+ * @remarks 	Interrupt handler for the IEEE 1588 module
+ * 		The Interrupts are handled in the following order
+ *  		- 1 - Target Time Reached/Hit Condition
+ *  		- 2 - Auxiliary Master Timestamp
+ *  		- 3 - Auxiliary Slave Timestamp
+ *  		- 4 - pulse per second
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_handler(void)
+{
+	struct ioh1588TimeValue tgt_time = { 0, 0 };
+	struct ioh1588TimeValue aux_time = { 0, 0 };
+	unsigned long pps;
+
+	/* If valid callbacks are available process each interrupt */
+
+	/* Handle Target Time Reached or Exceeded Interrupt */
+	if ((NULL != ioh_tt_cbptr) && (TRUE == ioh_1588_ttm_evt_get())) {
+		IOH_DEBUG
+		("ioh_1588_handler:Target Time Reached or Exceeded \
+								Interrupt\n");
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_ttm_imask_clear\
+				to disable interrupts\n");
+		/* Disable interrupt */
+		ioh_1588_ttm_imask_clear();
+
+		/* Target Time registers contents  */
+		ioh_1588_tgt_snap_get(&tgt_time.timeValueLowWord,
+				      &tgt_time.timeValueHighWord);
+		IOH_DEBUG("ioh_1588_handler:target time-low=%lx,high=%lx\n",
+			  tgt_time.timeValueLowWord,
+			  tgt_time.timeValueHighWord);
+
+		IOH_DEBUG("ioh_1588_handler:invoking callback\n");
+		/* Invoke client callback */
+		(*ioh_tt_cbptr) (tgt_time);
+
+		/* Clear the target time reached condition (ttipend bit) */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_ttm_evt_clear\n");
+		ioh_1588_ttm_evt_clear();
+	}
+
+	/* Handle Auxiliary Master Mode Snapshot Interrupt */
+	if ((NULL != ioh_am_cbptr) && (TRUE == ioh_1588_amms_evt_get())) {
+		IOH_DEBUG
+		("ioh_1588_handler:Auxiliary Master Mode Snapshot Interrupt\n");
+		/* Disable interrupt */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_amms_imask_clear\
+				to disable interrupts\n");
+		ioh_1588_amms_imask_clear();
+
+		/* Fetch Auxiliary Master Mode Snapshot */
+		ioh_1588_aux_master_snap_get(&aux_time.timeValueLowWord,
+					     &aux_time.timeValueHighWord);
+		IOH_DEBUG
+		("ioh_1588_handler:Auxiliary Master Mode Snapshot-low=%lx,\
+			high=%lx\n",
+			aux_time.timeValueLowWord, aux_time.timeValueHighWord);
+
+		IOH_DEBUG("ioh_1588_handler:invoking callback\n");
+		/* Return Auxiliary Master Mode Snapshot */
+		(*ioh_am_cbptr) (IOH_1588_AUXMODE_MASTER, aux_time);
+
+		/* Clear the snapshot availability condition */
+		IOH_DEBUG
+		    ("ioh_1588_handler:invoking ioh_1588_amms_evt_clear\n");
+		ioh_1588_amms_evt_clear();
+	}
+
+	/* Handle Auxiliary Slave Mode Snapshot Interrupt */
+	if ((NULL != ioh_as_cbptr) && (TRUE == ioh_1588_asms_evt_get())) {
+		IOH_DEBUG
+		("ioh_1588_handler:Auxiliary Slave Mode Snapshot Interrupt\n");
+		/* Disable interrupt */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_asms_imask_clear\
+				to disable interrupts\n");
+		ioh_1588_asms_imask_clear();
+
+		/* Fetch Auxiliary Slave Mode Snapshot */
+		ioh_1588_aux_slave_snap_get(&aux_time.timeValueLowWord,
+					    &aux_time.timeValueHighWord);
+		IOH_DEBUG
+		("ioh_1588_handler:Auxiliary Master Mode Snapshot-low=%lx,\
+			high=%lx\n",
+			aux_time.timeValueLowWord, aux_time.timeValueHighWord);
+
+		/* Return Auxiliary Slave Mode Snapshot */
+		IOH_DEBUG("ioh_1588_handler:invoking callback\n");
+		(*ioh_as_cbptr) (IOH_1588_AUXMODE_SLAVE, aux_time);
+
+		/* Clear the snapshot availability condition */
+		IOH_DEBUG
+		    ("ioh_1588_handler:invoking ioh_1588_asms_evt_clear\n");
+		ioh_1588_asms_evt_clear();
+	}
+
+	/* Handle Pulse Per Second Interrupt */
+	if ((NULL != ioh_pps_cbptr) && (TRUE == ioh_1588_pps_evt_get())) {
+		IOH_DEBUG("ioh_1588_handler:Pulse Per Second  Interrupt\n");
+		/* Disable interrupt */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_pps_imask_clear\
+				to disable interrupts\n");
+		ioh_1588_pps_imask_clear();
+
+		/* Fetch PPS compare register */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_pps_get\n");
+		ioh_1588_pps_get(&pps);
+
+		/* Invoke the call back */
+		IOH_DEBUG("ioh_1588_handler:invoking callback\n");
+		(*ioh_pps_cbptr) (pps);
+
+		/* Clear the snapshot availability condition */
+		IOH_DEBUG("ioh_1588_handler:invoking ioh_1588_pps_evt_clear\n");
+		ioh_1588_pps_evt_clear();
+
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_version_get(
+ *		enum ioh1588PTPPort ptpPort, enum ioh1588PTPVersion *ptpVersion)
+ *
+ * @brief 	Retrieves IEEE 1588 PTP version supported on the given PTP port.
+ *
+ * @remarks 	This API retrieves IEEE 1588 PTP version supported on given PTP
+ *		 port.
+ * 		The main steps followed in this function are:
+ *		- Return IOH_1588_INVALIDPARAM if ptpPort passed is not valid or
+ *		 ptpVersion passed is NULL
+ *		- Ensure that the module is initialized and the port is valid
+ *		- Return the PTP version that is supported from the
+ *		 TS_Channel_Control register, bit 31
+ *
+ *
+ * @param 	ptpPort 	[IN] 	 	PTP port
+ * @param 	ptpVersion 	[OUT]		Version supported on PTP port
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation is successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ */
+enum ioh_status
+ioh_1588_ptp_version_get(enum ioh1588PTPPort ptpPort, \
+			enum ioh1588PTPVersion *ptpVersion)
+{
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) || (ptpVersion == NULL)) {
+		IOH_DEBUG("ioh_1588_ptp_version_get:invalid params\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	IOH_DEBUG("ioh_1588_ptp_version_get:invoking ioh_1588_version_get\n");
+	*ptpVersion = ioh_1588_version_get();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_version_set(
+ *		enum ioh1588PTPPort ptpPort,
+ *		 enum ioh1588PTPVersion ptpVersion)
+ *
+ * @brief 	Configures IEEE 1588 PTP version to be used on given PTP port.
+ *
+ * @remarks 	This API set the IEEE 1588 PTP version to be used on given PTP
+ *		 port.
+ * 		The main steps followed in this function are:
+ * 		- Validate parameter
+ * 		- Ensure that the module is initialized and the version
+ *		 requested is valid
+ * 		- Set the version in TS_Channel_Control register, bit 31
+ *
+ *
+ * @param 	ptpPort 	[IN]  	PTP port
+ * @param 	ptpVersion 	[IN]	Version to be supported on PTP port
+ *
+ *
+ * @retval	enum ioh_status
+ *  	@li IOH_1588_SUCCESS - Operation is successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ */
+enum ioh_status
+ioh_1588_ptp_version_set(enum ioh1588PTPPort ptpPort, \
+			enum ioh1588PTPVersion ptpVersion)
+{
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) ||
+	    ((ptpVersion != IOH_1588PTP_VERSION_0) &&
+	     (ptpVersion != IOH_1588PTP_VERSION_1))) {
+		IOH_DEBUG("ioh_1588_ptp_version_set:invalid params\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	IOH_DEBUG("ioh_1588_ptp_version_get:invoking ioh_1588_version_set\n");
+	ioh_1588_version_set(ptpVersion);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_operation_mode_set(
+ *		enum ioh1588PTPPort ptpPort,
+ *		 enum ioh1588PTPOperationMode ptpMode)
+ *
+ * @brief 	Configure the IEEE 1588 PTP operation mode of given PTP port.
+ *
+ * @remarks 	This API will set the operation mode on given PTP port.
+ * 		The main steps followed in this function are:
+ * 		- Ensure that the module is initialized and the mode requested
+ *		 is valid
+ * 		- If not valid, return status IOH_1588_INVALIDPARAM
+ * 		- Set the requested operation mode in TS_Channel_Control
+ *		 register, bits 16-20
+ *
+ *
+ * @param 	ptpPort 	[IN] 	PTP port to configure
+ * @param 	ptpMode 	[IN]	Operation mode to be used
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid parameters passed
+ */
+enum ioh_status
+ioh_1588_ptp_operation_mode_set(enum ioh1588PTPPort ptpPort,
+				enum ioh1588PTPOperationMode ptpMode)
+{
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) ||
+	    ((ptpMode != IOH_1588PTP_OP_MODE_SYNC_DELAYREQ_MSGS) &&
+	     (ptpMode != IOH_1588PTP_OP_MODE_V1_ALL_MSGS) &&
+	     (ptpMode != IOH_1588PTP_OP_MODE_V1_V2_EVENT_MSGS) &&
+	     (ptpMode != IOH_1588PTP_OP_MODE_V1_V2_ALL_MSGS))) {
+		IOH_DEBUG("ioh_1588_ptp_operation_mode_set:invalid params\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	IOH_DEBUG("ioh_1588_ptp_version_get:invoking ioh_1588_op_mode_set\n");
+	ioh_1588_op_mode_set(ptpMode);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_ptp_operation_mode_get(
+ *			enum ioh1588PTPPort ptpPort,
+ *			enum ioh1588PTPOperationMode *ptpMode)
+ *
+ * @brief 	Gets the current PTP operation mode of given PTP port.
+ *
+ * @remarks 	This API will get the operation mode of given PTP port.
+ * 		The main steps followed in this function are:
+ * 		- Ensure that the module is initialized and the port is valid
+ * 		- If not valid, return status IOH_1588_INVALIDPARAM
+ * 		- Return the PTP operation mode that is currently in use by
+ * 		reading the TS_Channel_Control register, bits 16-20
+ *
+ *
+ * @param 	ptpPort 	[IN] 	PTP port to configure
+ * @param 	ptpMode 	[OUT]	Address where PTP operation mode is
+ *					 returned
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status
+ioh_1588_ptp_operation_mode_get(enum ioh1588PTPPort ptpPort,
+				enum ioh1588PTPOperationMode *ptpMode)
+{
+	/* Verify the parameters for proper values */
+	if ((ptpPort != IOH_1588_GBE_0_1588PTP_PORT) || (ptpMode == NULL)) {
+		IOH_DEBUG("ioh_1588_ptp_operation_mode_get:invalid params\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	IOH_DEBUG
+	    ("ioh_1588_ptp_operation_mode_get:invoking ioh_1588_op_mode_get\n");
+	*ptpMode = ioh_1588_op_mode_get();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_pulse_per_sec_interrupt_enable(
+ *		ioh1588PulsePerSecondCallback callBack)
+ *
+ * @brief 	Enable the Pulse Per Second match interrupt
+ *
+ * @remarks 	This API will enable the Pulse Per Second match interrupt.
+ * 		This interrupt is generated when the low word of System
+ * 		Time matches the value in the Pulse Per Second compare
+ * 		register in the IEEE hardware assist block. The main steps
+ * 		followed in this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Modify the Time Sync Controller register to enable the
+ *		 interrupt
+ * 		- Set the callback routine
+ *
+ * @param 	callBack 	[IN] 	Routine to be invoked when interrupt
+ *					 fires
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status
+ioh_1588_pulse_per_sec_interrupt_enable(ioh1588PulsePerSecondCallback callBack)
+{
+	/* Verify the parameter */
+	if ((ioh1588PulsePerSecondCallback) NULL == callBack) {
+		IOH_DEBUG
+		    ("ioh_1588_pulse_per_sec_interrupt_enable:invalid params\
+				returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Register the Callback */
+	ioh_pps_cbptr = callBack;
+
+	/* Set target time interrupt mask */
+	IOH_DEBUG("ioh_1588_pulse_per_sec_interrupt_enable:invoking \
+				ioh_1588_pps_imask_set\n");
+	ioh_1588_pps_imask_set();
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_pulse_per_sec_interrupt_disable(void)
+ *
+ * @brief 	Disable the Pulse Per Second match interrupt
+ *
+ * @remarks 	This API will disable the Pulse Per Second match interrupt.
+ * 		This interrupt is generated when the low word of System
+ * 		Time matches the value in the Pulse Per Second compare
+ * 		register in the IEEE hardware assist block. The main
+ * 		steps followed in this function are:
+ * 		- Modify the Time Sync Controller register to disable the
+ *		 interrupt
+ * 		- Clear the callback routine
+ *
+ * @param	None
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_pulse_per_sec_interrupt_disable(void)
+{
+	/* Clear pulse per second interrupt mask */
+	IOH_DEBUG("ioh_1588_pulse_per_sec_interrupt_disable:invoking \
+				ioh_1588_pps_imask_clear\n");
+	ioh_1588_pps_imask_clear();
+
+	/* Unregister the Callback */
+	ioh_pps_cbptr = (ioh1588PulsePerSecondCallback) NULL;
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_pulse_per_sec_time_set(unsigned long
+ *		 ppsTime)
+ *
+ * @brief 	Sets the Pulse Per Second match time in the IEEE 1588 hardware
+ *		 assist block
+ *
+ * @remarks 	This API will set the PPS match register with the value supplied
+ * 		The main steps followed in this function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Set the time in PPS Compare Register
+ *
+ *
+ * @param 	ppsTime	[IN] 	Value to be stored in pps match register
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation is successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status ioh_1588_pulse_per_sec_time_set(unsigned long ppsTime)
+{
+	unsigned long old_mask = FALSE;
+
+	/* Retrieve existing pps mask value */
+	old_mask = ioh_1588_pps_imask_get();
+	IOH_DEBUG
+	    ("ioh_1588_pulse_per_sec_time_set:target time interrupt mask=%lx\n",
+	     old_mask);
+
+	/*
+	 * Clear the pps time interrupt mask so that the interrupt will not come
+	 * during the time we manipulate the registers.
+	 */
+	IOH_DEBUG
+	("ioh_1588_pulse_per_sec_time_set:invoking ioh_1588_pps_imask_clear\
+	to clear the pps interrupt mask\n");
+	ioh_1588_pps_imask_clear();
+
+	/* Update the PPS time */
+	IOH_DEBUG
+	    ("ioh_1588_pulse_per_sec_time_set:invoking ioh_1588_pps_set\n");
+
+	ioh_1588_pps_set(ppsTime);
+
+	/*
+	 * Let the hardware assist re-evaluate the pps reached
+	 * condition based on the new pps value
+	 */
+	IOH_DEBUG
+	("ioh_1588_pulse_per_sec_time_set:invoking ioh_1588_pps_evt_clear\n");
+	ioh_1588_pps_evt_clear();
+
+	/* Restore the preserved pps interrupt mask value */
+	if (TRUE == old_mask) {
+		IOH_DEBUG
+		("ioh_1588_pulse_per_sec_time_set:invoking \
+		ioh_1588_pps_imask_set\n");
+		ioh_1588_pps_imask_set();
+	}
+
+	IOH_DEBUG
+	    ("ioh_1588_pulse_per_sec_time_set:returning IOH_1588_SUCCESS\n");
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_pulse_per_sec_time_get(
+ *		unsigned long *ppsTime)
+ *
+ * @brief 	Gets the Pulse Per Second match time from the IEEE 1588 hardware
+ *		 assist block
+ *
+ * @remarks 	This API will get the PPS match register content
+ * 		from IEEE 1588 block. The main steps followed in this
+ * 		function are:
+ * 		- Return IOH_1588_INVALIDPARAM if argument passed is NULL
+ * 		- Return the time from PPS compare register
+ *
+ *
+ * @param 	ppsTime 	[OUT] 	Buffer for returning the pps match value
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status ioh_1588_pulse_per_sec_time_get(unsigned long *ppsTime)
+{
+	/* Verify the parameter */
+	if ((unsigned long *)NULL == ppsTime) {
+		IOH_DEBUG("ioh_1588_pulse_per_sec_time_get:invalid params\
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	/* Retrieve PPS Value */
+	IOH_DEBUG
+	    ("ioh_1588_pulse_per_sec_time_get:invoking ioh_1588_pps_get\n");
+	ioh_1588_pps_get(ppsTime);
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_eth_enable(void)
+ *
+ * @brief 	Sets the eth_enb bit (bit 0) of Ethernet-CAN Select Register
+ * @remarks	This API enables the IEEE 1588 hardware time stamping of PTP
+ *		 traffic
+ * 		on the  Ethernet interface
+ *
+ * @param	None
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_eth_enable(void)
+{
+	if (ioh_1588_base != 0) {
+		IOH_DEBUG
+		    ("ioh_1588_eth_enable:invoking ioh_1588_eth_enable_set\n");
+		ioh_1588_eth_enable_set();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_eth_disable(void)
+ *
+ * @brief 	Clears the eth_enb bit (bit 0) of Ethernet-CAN Select Register
+ * @remarks	This API disables the IEEE 1588 hardware time stamping of PTP
+ *		 traffic
+ * 		on the  Ethernet interface
+ *
+ * @param	None
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_eth_disable(void)
+{
+	if (ioh_1588_base != 0) {
+		IOH_DEBUG
+		("ioh_1588_eth_disable:invoking ioh_1588_eth_enable_clear\n");
+		ioh_1588_eth_enable_clear();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_can_enable(void)
+ *
+ * @brief 	Sets the can_enb bit (bit 1) of Ethernet-CAN Select Register
+ * @remraks 	This API enables the IEEE 1588 hardware time stamping of PTP
+ *		 traffic
+ * 		on the CAN interface
+ *
+ * @param	None
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_can_enable(void)
+{
+	if (ioh_1588_base != 0) {
+		IOH_DEBUG
+		    ("ioh_1588_can_enable:invoking ioh_1588_can_enable_set\n");
+		ioh_1588_can_enable_set();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_can_disable(void)
+ *
+ * @brief 	Clear the can_enb bit (bit 1) of Ethernet-CAN Select Register
+ * @remarks	This API disables the IEEE 1588 hardware time stamping of PTP
+ *		 traffic
+ * 		on the CAN interface
+ *
+ * @param	None
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ */
+enum ioh_status ioh_1588_can_disable(void)
+{
+	if (ioh_1588_base != 0) {
+		IOH_DEBUG
+		("ioh_1588_can_disable:invoking ioh_1588_can_enable_clear\n");
+		ioh_1588_can_enable_clear();
+	}
+
+	return IOH_1588_SUCCESS;
+}
+
+/**
+ *  @ingroup	IEEE_1588_UtilitiesAPI
+ *  @fn 	static int get_decimal(unsigned char ch)
+ *
+ *  @brief	Returns the decimal value of the passed
+ *  		hexadecimal value.
+ *
+ *  @note	Returns -1 if the passed arguement is invalid.
+ *
+ *  @param	ch	[IN]	The hexadecimal value that has to be converted.
+ *
+ *  @retval	int
+ *  		- On Success 	--> decimal Value
+ *  		- Invalid value	--> -1
+ */
+static int get_decimal(unsigned char ch)
+{
+	int ret;
+
+	if ((ch >= '0') && (ch <= '9')) {
+		ret = ch - '0';
+		return ret;
+	} else if ((ch >= 'A') && (ch <= 'F')) {
+		ret = 10 + ch - 'A';
+		return ret;
+	} else if ((ch >= 'a') && (ch <= 'f')) {
+		ret = 10 + ch - 'a';
+		return ret;
+	}
+
+	return -1;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_set_station_address (
+ *		unsigned char *addr)
+ *
+ * @brief 	This API sets the station address used by IEEE 1588 hardware
+ *		 when looking
+ * 		at PTP traffic on the  ethernet interface
+ *
+ * @param 	addr	[IN]  Address which contain the column separated
+ *							 address to be used
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Invalid address string
+ */
+enum ioh_status ioh_1588_set_station_address(unsigned char *addr)
+{
+	int i;
+
+	/* Verify the parameter */
+	if ((ioh_1588_base == 0) || (unsigned char *)NULL == addr) {
+		IOH_DEBUG("ioh_1588_set_station_address :invalid params\
+			returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {	/* For all station
+							 address bytes */
+		unsigned long val = 0;
+		int tmp;
+
+		tmp = get_decimal(addr[i * 3]);
+		if (tmp < 0) {
+			IOH_DEBUG("ioh_1588_set_station_address :invalid params\
+					returning IOH_1588_INVALIDPARAM\n");
+			return IOH_1588_INVALIDPARAM;
+		}
+		val = tmp * 16;
+		tmp = get_decimal(addr[(i * 3) + 1]);
+		if (tmp < 0) {
+			IOH_DEBUG("ioh_1588_set_station_address :invalid params\
+					returning IOH_1588_INVALIDPARAM\n");
+			return IOH_1588_INVALIDPARAM;
+		}
+		val += tmp;
+		if ((i < 5) && (addr[(i * 3) + 2] != ':')) {	/* Expects ':'
+							 separated addresses */
+			IOH_DEBUG("ioh_1588_set_station_address :invalid params\
+					returning IOH_1588_INVALIDPARAM\n");
+			return IOH_1588_INVALIDPARAM;
+		}
+
+		/* Ideally we should set the address only after validating
+							 entire string */
+		IOH_DEBUG
+		("ioh_1588_set_station_address \
+		:invoking ioh_1588_station_set\n");
+		ioh_1588_station_set(i, val);
+	}
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_get_station_address(char *addr)
+ * @brief 	This API gets the station address currently used by IEEE 1588
+ * 		hardware when looking at PTP traffic on the  ethernet interface
+ *
+ * @param 	addr  	[OUT]	Buffer to which column separated address is
+ *				 returned
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_SUCCESS - Operation successful
+ *      @li IOH_1588_INVALIDPARAM - Null parameter passed
+ */
+enum ioh_status ioh_1588_get_station_address(char *addr)
+{
+	int i;
+
+	/* Verify the parameter */
+	if ((char *)NULL == addr) {
+		IOH_DEBUG("ioh_1588_get_station_address:invalid params\
+					returning IOH_1588_INVALIDPARAM\n");
+		return IOH_1588_INVALIDPARAM;
+	}
+
+	for (i = 0; i < IOH_1588_STATION_BYTES; i++) {
+		unsigned long val = 0;
+
+		ioh_1588_station_get(i, &val);
+		addr[i * 3] = val / 16;
+		if (addr[i * 3] > 9)
+			addr[i * 3] += 'a' - 10;
+		else
+			addr[i * 3] += '0';
+		addr[i * 3 + 1] = val % 16;
+		if (addr[i * 3 + 1] > 9)
+			addr[i * 3 + 1] += 'a' - 10;
+		else
+			addr[i * 3 + 1] += '0';
+		addr[i * 3 + 2] = ':';
+	}
+	addr[17] = '\0';
+	return IOH_1588_SUCCESS;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_target_time_interrupt_enable(
+ *		void *callBack)
+ *
+ * @brief 	This API just returns an error.
+ *
+ * @remarks 	This API is just for compatibility. It just returns an error.
+ *
+ * @param 	callBack 	[IN] 	Callback to be invoked when interrupt
+ *					 fires
+ *
+ *
+ * @retval 	enum ioh_status
+ * 	@li IOH_1588_UNSUPPORTED - Operation is not supported
+ */
+enum ioh_status ioh_1588_aux_target_time_interrupt_enable(void *callBack)
+{
+	IOH_DEBUG("ioh_1588_aux_target_time_interrupt_enable:unsupported\n");
+	return IOH_1588_UNSUPPORTED;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_target_time_interrupt_disable(void)
+ *
+ * @brief 	This API just returns an error.
+ *
+ * @remarks 	This API is just for compatibility. It just returns an error.
+ *
+ * @param	None
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_UNSUPPORTED - Operation is not supported
+ */
+enum ioh_status ioh_1588_aux_target_time_interrupt_disable(void)
+{
+	IOH_DEBUG("ioh_1588_aux_target_time_interrupt_disable:unsupported\n");
+	return IOH_1588_UNSUPPORTED;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_target_time_poll(
+ *		unsigned long *attmPollFlag,
+ *		struct ioh1588TimeValue *targetTime)
+ *
+ * @brief 	This API just returns an error.
+ *
+ * @remarks 	This API is just for compatibility. It just returns an error.
+ *
+ * @param 	attmPollFlag 	[OUT] 	Flag returning the availablity of a
+ *					 snapshot
+ * @param 	targetTime 	[OUT] 	Snapshot captured
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_UNSUPPORTED - Operation supported
+ */
+enum ioh_status
+ioh_1588_aux_target_time_poll(unsigned long *attmPollFlag,
+			      struct ioh1588TimeValue *targetTime)
+{
+	IOH_DEBUG("ioh_1588_aux_target_time_poll:unsupported\n");
+	return IOH_1588_UNSUPPORTED;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ *  @fn 	enum ioh_status ioh_1588_aux_target_time_set(
+ *		struct ioh1588TimeValue targetTime)
+ *
+ * @brief 	This API just returns an error.
+ *
+ * @remarks 	This API is just for compatibility. It just returns an error.
+ *
+ * @param 	targetTime [IN] 	Time to set to
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_UNSUPPORTED - Operation supported
+ */
+enum ioh_status ioh_1588_aux_target_time_set(struct ioh1588TimeValue targetTime)
+{
+	IOH_DEBUG("ioh_1588_aux_target_time_set:unsupported\n");
+	return IOH_1588_UNSUPPORTED;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+ * @fn 		enum ioh_status ioh_1588_aux_target_time_get(
+ *		struct ioh1588TimeValue *targetTime)
+ *
+ * @brief 	This API just returns an error.
+ *
+ * @remarks 	This API is just for compatibility. It just returns an error.
+ *
+ * @param 	targetTime	[OUT] 	Buffer for returning time snapshot
+ *
+ *
+ * @retval	enum ioh_status
+ * 	@li IOH_1588_UNSUPPORTED - Operation supported
+ */
+enum ioh_status ioh_1588_aux_target_time_get(
+		struct ioh1588TimeValue *targetTime)
+{
+	IOH_DEBUG("ioh_1588_aux_target_time_get:unsupported\n");
+	return IOH_1588_UNSUPPORTED;
+}
+
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+  *
+  * @fn		int ioh_1588_eth_can_get(void)
+  *
+  * @brief      This function returns the modes [ethernet/CAN] enabled
+  *
+  * @retval     int
+  * 		- the modes enabled
+  */
+int ioh_1588_eth_can_get(void)
+{
+	int ieee_mode = 0;
+
+	if (ioh_1588_eth_enable_get() == 1)
+		ieee_mode |= IOH_IEEE1588_ETH;
+	if (ioh_1588_can_enable_get() == 1)
+		ieee_mode |= IOH_IEEE1588_CAN;
+
+	return ieee_mode;
+}
+
+#ifdef IOH_IEEE1588_A0_A1_SAMPLE_BUG
+/*! @ingroup 	IEEE_1588_HALLayerAPI
+  *
+  * @fn			void ioh_1588_set_system_time_count(void)
+  *
+  * @brief      This function enables all 64 bits in system time registers
+  *             [high & low]. This is a work-around for non continuous value
+  *				in the SystemTime Register
+  *
+  * @retval     none
+  */
+void ioh_1588_set_system_time_count(void)
+{
+	IOH_REG_32_WRITE((ioh_1588_base + 0xC0), 0x1);
+	IOH_REG_32_WRITE((ioh_1588_base + 0xC4), 0xFFFFFFFF);
+	IOH_REG_32_WRITE((ioh_1588_base + 0xC0), 0x0);
+}
+#endif
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.h topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.h
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.h	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_hal.h	2010-03-09 07:40:00.000000000 +0900
@@ -0,0 +1,885 @@
+ /*!
+  * @file ioh_1588_hal.h
+  * @brief
+  * This file lists the declarations of IEEE_1588_HALLayer APIs.
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intel EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ *
+ */
+
+#ifndef IOH_1588_HAL_H
+#define IOH_1588_HAL_H
+
+#include "pch_1588_main.h"
+
+/* IOH 1588 Hardware Assist Module Register offsets */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_OFFSET
+@brief			TS Control Register Offset
+*/
+#define IOH_1588_TSC_OFFSET    (0x00)	/* TS_Control */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_OFFSET
+@brief			TS Event Register Offset
+*/
+#define IOH_1588_TSE_OFFSET    (0x04)	/* TS_Event */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ADD_OFFSET
+@brief			TS Addend Register Offset
+*/
+#define IOH_1588_ADD_OFFSET    (0x08)	/* TS_Addend */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ACC_OFFSET
+@brief			TS Accumulator Register Offset
+*/
+#define IOH_1588_ACC_OFFSET    (0x0C)	/* TS_Accum */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TST_OFFSET
+@brief			TS Test Register Offset
+*/
+#define IOH_1588_TST_OFFSET    (0x10)	/* TS_Test */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_PPS_OFFSET
+@brief			TS PPS Compare Register Offset
+*/
+#define IOH_1588_PPS_OFFSET    (0x14)	/* TS_PPS_Compare */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_STL_OFFSET
+@brief			TS System Time Low Register Offset
+*/
+#define IOH_1588_STL_OFFSET    (0x20)	/* TS_SysTimeLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_STH_OFFSET
+@brief			TS System Time High Register Offset
+*/
+#define IOH_1588_STH_OFFSET    (0x24)	/* TS_SysTimeHi */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TTL_OFFSET
+@brief			TS Target Time Low Register Offset
+*/
+#define IOH_1588_TTL_OFFSET    (0x28)	/* TS_TrgtLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TTH_OFFSET
+@brief			TS Target Time High Register Offset
+*/
+#define IOH_1588_TTH_OFFSET    (0x2c)	/* TS_TrgtHi */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ASSL_OFFSET
+@brief			TS Aux Slave Mode Snapshot Low Register Offset
+*/
+#define IOH_1588_ASSL_OFFSET   (0x30)	/* TS_ASMSLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ASSH_OFFSET
+@brief			TS Aux Slave Mode Snapshot High Register Offset
+*/
+#define IOH_1588_ASSH_OFFSET   (0x34)	/* TS_ASMSHi */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ASSH_OFFSET
+@brief			TS Aux Master Mode Snapshot Low Register Offset
+*/
+#define IOH_1588_AMSL_OFFSET   (0x38)	/* TS_AMMSLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_AMSH_OFFSET
+@brief			TS Aux Master Mode Snapshot High Register Offset
+*/
+#define IOH_1588_AMSH_OFFSET   (0x3C)	/* TS_AMMSHi */
+
+/* Ethernet */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_OFFSET
+@brief			TS Channel Control Register Offset
+*/
+#define IOH_1588_CC_OFFSET     (0x40)	/* TS_Ch_Contr */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CE_OFFSET
+@brief			TS Channel Event Register Offset
+*/
+#define IOH_1588_CE_OFFSET     (0x44)	/* TS_Ch_Event */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_XSL_OFFSET
+@brief			TS Tx Snapshot Low Register Offset
+*/
+#define IOH_1588_XSL_OFFSET    (0x48)	/* TS_TxSnapLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_XSH_OFFSET
+@brief			TS Tx Snapshot High Register Offset
+*/
+#define IOH_1588_XSH_OFFSET    (0x4C)	/* TS_TxSnapHi */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_RSL_OFFSET
+@brief			TS Rx Snapshot Low Register Offset
+*/
+#define IOH_1588_RSL_OFFSET    (0x50)	/* TS_RxSnapLo */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_RSH_OFFSET
+@brief			TS Rx Snapshot High Register Offset
+*/
+#define IOH_1588_RSH_OFFSET    (0x54)	/* TS_RxSnapHi */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_UID_OFFSET
+@brief			TS Source UUID Low Register Offset
+*/
+#define IOH_1588_UID_OFFSET    (0x58)	/* TS_SrcUUID */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_SID_OFFSET
+@brief			TS Source UUID High/SequenceID Register Offset
+*/
+#define IOH_1588_SID_OFFSET    (0x5C)	/* TS_SrcUUID */
+
+/* CAN */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CCE_OFFSET
+@brief			TS CAN Channel Status Register Offset
+*/
+#define IOH_1588_CCE_OFFSET	(0x60)	/* TS_CAN_Stat */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CXSL_OFFSET
+@brief			TS CAN Snapshot Low Register Offset
+*/
+#define IOH_1588_CXSL_OFFSET	(0x64)	/* TS_CAN_Snap */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CXSH_OFFSET
+@brief			TS CAN Snapshot High Register Offset
+*/
+#define	IOH_1588_CXSH_OFFSET	(0x68)	/* TS_CAN_Snap */
+
+/* Selector */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ECS_OFFSET
+@brief			TS Ethernet/CAN Select Register Offset
+*/
+#define	IOH_1588_ECS_OFFSET	(0x6c)	/* TS_SEL */
+
+/* Station Address 1-6 */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_STA_OFFSET
+@brief			TS Station Address Register Offset
+*/
+#define	IOH_1588_STA_OFFSET	(0x70)	/* TS_ST1 */
+
+/* Bit Masks of Control Register */
+/* Hardware Assist Reset */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_RESET_SHIFT
+@brief			Reset Bit position in Control Register
+*/
+#define IOH_1588_TSC_RESET_SHIFT        0
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_RESET
+@brief			Bit Maks for Reset Bit in Control Register
+*/
+#define IOH_1588_TSC_RESET        (1 << IOH_1588_TSC_RESET_SHIFT)
+
+/* Target Time Interrupt Mask */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_TIM_SHIFT
+@brief			Bit position of Target Time Interrupt Bit in Control
+			 Register
+*/
+#define IOH_1588_TSC_TTM_SHIFT     1
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_TIM_MASK
+@brief			Bit Mask for Target Time Interrupt in Control Register
+*/
+#define IOH_1588_TSC_TTM_MASK     (1 << IOH_1588_TSC_TTM_SHIFT)
+
+/* Auxiliary Slave Mode snapshot Interrupt Mask */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_ASMS_SHIFT
+@brief			Bit position of Aux Slave Mode snapshot
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_ASMS_SHIFT    2
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_ASMS_MASK
+@brief			Bit Mask for Aux Slave Mode snapshot
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_ASMS_MASK    (1 << IOH_1588_TSC_ASMS_SHIFT)
+
+/* Auxiliary Master Mode snapshot Interrupt Mask */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_AMMS_SHIFT
+@brief			Bit position for for Aux Master Mode snapshot
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_AMMS_SHIFT    3
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_AMMS_MASK
+@brief			Bit mask for for Aux Master Mode snapshot
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_AMMS_MASK    (1 << IOH_1588_TSC_AMMS_SHIFT)
+
+/* Pulse Per Second Interrupt Mask */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_PPSM_SHIFT
+@brief			Bit position of Pulse Per Second
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_PPSM_SHIFT    4
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSC_PPSM_MASK
+@brief			Bit mask of Pulse Per Second
+				Interrupt in Control Register
+*/
+#define IOH_1588_TSC_PPSM_MASK    (1 << IOH_1588_TSC_PPSM_SHIFT)
+
+/* Bit Masks of Event Register */
+/* Target Time Interrupt Pending Event */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_TTIPEND_SHIFT
+@brief			Bit position of Target Time Interrupt
+				Pending in Event Register
+*/
+#define IOH_1588_TSE_TTIPEND_SHIFT      1
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_TTIPEND
+@brief			Bit mask of Target Time Interrupt
+				Pending in Event Register
+*/
+#define IOH_1588_TSE_TTIPEND      (1 << IOH_1588_TSE_TTIPEND_SHIFT)
+
+/* Auxiliary Slave Mode snapshot Event */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_SNS_SHIFT
+@brief			Bit position of Aux Slave Mode snapshot
+				in Event Register
+*/
+#define IOH_1588_TSE_SNS_SHIFT          2
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_SNS
+@brief			Bit mask of Aux Slave Mode snapshot
+				in Event Register
+*/
+#define IOH_1588_TSE_SNS          (1 << IOH_1588_TSE_SNS_SHIFT)
+
+/* Auxiliary Master Mode snapshot Event */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_SNM_SHIFT
+@brief			Bit position of Aux Master Mode snapshot
+				in Event Register
+*/
+#define IOH_1588_TSE_SNM_SHIFT          3
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_SNM
+@brief			Bit mask of Aux Master Mode snapshot
+				in Event Register
+*/
+#define IOH_1588_TSE_SNM          (1 << IOH_1588_TSE_SNM_SHIFT)
+
+/* Pulse Per Second Match */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_PPS_SHIFT
+@brief			Bit position of Pusle Per Second Match
+				in Event Register
+*/
+#define IOH_1588_TSE_PPS_SHIFT          4
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_TSE_PPS
+@brief			Bit mask of Pusle Per Second Match
+				in Event Register
+*/
+#define IOH_1588_TSE_PPS          (1 << IOH_1588_TSE_PPS_SHIFT)
+
+/* Bit Masks of Channel Control Register */
+/* Timestamp Master or Slave Mode Control Flag */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_MM_SHIFT
+@brief			Bit position of Timestamp Master/Slave Mode
+				in Channel Control Register
+*/
+#define IOH_1588_CC_MM_SHIFT            0
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_MM
+@brief			Bit mask of Timestamp Master/Slave Mode
+				control flag in
+				in Channel Control Register
+*/
+#define IOH_1588_CC_MM            (1 << IOH_1588_CC_MM_SHIFT)
+
+/* Timestamp All Messages Control Flag */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_TA_SHIFT
+@brief			Bit position of Timestamp all messages
+				Mode control flag
+				in Channel Control Register
+*/
+#define IOH_1588_CC_TA_SHIFT           1
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_TA
+@brief			Bit mask of Timestamp all messages
+				Mode control flag
+				in Channel Control Register
+*/
+#define IOH_1588_CC_TA            (1 << IOH_1588_CC_TA_SHIFT)
+
+/* Mode bits */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_MODE_SHIFT
+@brief			Bit position of mode bits
+				in Channel Control Register
+*/
+#define IOH_1588_CC_MODE_SHIFT    16
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_MODE_MASK
+@brief			Bit mask for mode bits
+				in Channel Control Register
+*/
+#define IOH_1588_CC_MODE_MASK     (0x001F0000)
+
+/* Version bit */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_VERSION_SHIFT
+@brief			Bit position for version bits
+				in Channel Control Register
+*/
+#define IOH_1588_CC_VERSION_SHIFT 31
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CC_VERSION
+@brief			Bit mask for version bits
+				in Channel Control Register
+*/
+#define IOH_1588_CC_VERSION       (1 << IOH_1588_CC_VERSION_SHIFT)
+
+/* Bit Masks of Channel Event Register */
+/* Transmit Snapshot Locked Indicator Flag */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CE_TXS
+@brief			Bit mask for Transmit Snapshot Locked bit
+				in Channel Event Register
+*/
+#define IOH_1588_CE_TXS           (1 << 0)
+
+/* Receive Snapshot Locked Indicator Flag */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CE_TXS
+@brief			Bit mask for Receive Snapshot Locked bit
+				in Channel Event Register
+*/
+#define IOH_1588_CE_RXS           (1 << 1)
+
+/* Bit Masks of CAN Channel Event Register */
+/* Overrun Indicator Flag */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CE_OVR
+@brief			Bit mask for Overrun Indicator bit
+				in Channel Event Register
+*/
+#define IOH_1588_CE_OVR           (1 << 0)
+
+/* Valid Indicator Flag */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_CE_VAL
+@brief			Bit mask for Valid Indicator bit
+				in Channel Event Register
+*/
+#define IOH_1588_CE_VAL           (1 << 1)
+
+/* Ethernet Enable bit */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ECS_ETH_SHIFT
+@brief			Bit position for Ethernet Enable bit
+				in Ethernet/CAN select Register
+*/
+#define IOH_1588_ECS_ETH_SHIFT    0
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ECS_ETH
+@brief			Bit mask for Ethernet Enable bit
+				in Ethernet/CAN select Register
+*/
+#define IOH_1588_ECS_ETH          (1 << IOH_1588_ECS_ETH_SHIFT)
+/* Can Enable bit */
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ECS_CAN_SHIFT
+@brief			Bit position for CAN Enable bit
+				in Ethernet/CAN select Register
+*/
+#define IOH_1588_ECS_CAN_SHIFT    1
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_ECS_CAN
+@brief			Bit mask for CAN Enable bit
+				in Ethernet/CAN select Register
+*/
+#define IOH_1588_ECS_CAN          (1 << IOH_1588_ECS_CAN_SHIFT)
+
+/* Station Address bytes */
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			IOH_1588_STATION_BYTES
+@brief			Bytes for Station Address
+*/
+#define IOH_1588_STATION_BYTES    6
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@def			DRIVER_NAME
+@brief			The name of this driver
+*/
+#define DRIVER_NAME              "ioh_ieee1588"
+
+#define IOH_IEEE1588_ETH          (1 << 0)
+#define IOH_IEEE1588_CAN          (1 << 1)
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@typedef	typedef void (*ioh1588TargetTimeCallback)
+					(struct ioh1588TimeValue tgt_time)
+@brief		Pointer for Callback function for Target Time interrupt
+@see
+				- ioh_1588_blpl_base_address_set
+				- ioh_1588_target_time_interrupt_enable
+				- ioh_1588_target_time_interrupt_disable
+				- ioh_1588_target_time_poll
+				- ioh_1588_reset
+*/
+typedef void (*ioh1588TargetTimeCallback) (struct ioh1588TimeValue tgt_time);
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@typedef	typedef void (*ioh1588AuxTimeCallback)
+				(enum ioh1588AuxMode aux_mode,
+				struct ioh1588TimeValue aux_time)
+@brief			Pointer for Callback function for Aux Time interrupt
+@see
+				- ioh_1588_blpl_base_address_set
+				- ioh_1588_aux_time_interrupt_enable
+				- ioh_1588_aux_time_interrupt_disable
+				- ioh_1588_aux_time_poll
+				- ioh_1588_reset
+*/
+typedef void (*ioh1588AuxTimeCallback) (enum ioh1588AuxMode aux_mode,
+					struct ioh1588TimeValue aux_time);
+
+/*! @ingroup    IEEE_1588_HALLayerAPI
+@typedef		typedef void (*ioh1588PulsePerSecondCallback)(
+							unsigned long pps)
+@brief			Pointer for Callback function for Pulse Per Second
+				 interrupt
+@see
+				- ioh_1588_blpl_base_address_set
+				- ioh_1588_pulse_per_sec_interrupt_enable
+				- ioh_1588_pulse_per_sec_interrupt_disable
+				- ioh_1588_reset
+*/
+typedef void (*ioh1588PulsePerSecondCallback) (unsigned long pps);
+
+/**
+ * prototypes of HAL APIs
+ */
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_blpl_base_address_set(unsigned long base_addr)
+ */
+enum ioh_status ioh_1588_blpl_base_address_set(unsigned long base_addr);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_port_config_set(
+ *			enum ioh1588PTPPort ptpPort,
+ *			enum ioh1588PTPPortMode ptpPortMode)
+ */
+enum ioh_status
+ioh_1588_ptp_port_config_set(enum ioh1588PTPPort ptpPort,
+			     enum ioh1588PTPPortMode ptpPortMode);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_port_config_get(
+ *		enum ioh1588PTPPort ptpPort,
+ * 		enum ioh1588PTPPortMode *ptpPortMode)
+ */
+enum ioh_status
+ioh_1588_ptp_port_config_get(enum ioh1588PTPPort ptpPort,
+				enum ioh1588PTPPortMode *ptpPortMode);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_rx_poll(
+ *			enum ioh1588PTPPort ptpPort,
+ *			 struct ioh1588PtpMsgData  *ptpMsgData)
+ *
+ *
+ */
+enum ioh_status
+ioh_1588_ptp_rx_poll(
+		enum ioh1588PTPPort ptpPort, \
+		struct ioh1588PtpMsgData *ptpMsgData);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_tx_poll(
+ *		enum ioh1588PTPPort ptpPort,
+ *		 struct ioh1588PtpMsgData  *ptpMsgData)
+ *
+ */
+enum ioh_status
+ioh_1588_ptp_tx_poll(
+		enum ioh1588PTPPort ptpPort, \
+		struct ioh1588PtpMsgData *ptpMsgData);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_system_time_set(
+ *		struct ioh1588TimeValue systemTime)
+ *
+ */
+enum ioh_status ioh_1588_system_time_set(struct ioh1588TimeValue systemTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_system_time_get(
+ *		struct ioh1588TimeValue *systemTime)
+ *
+ */
+enum ioh_status ioh_1588_system_time_get(struct ioh1588TimeValue *systemTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_tick_rate_set(unsigned long tickRate)
+ *
+ */
+enum ioh_status ioh_1588_tick_rate_set(unsigned long tickRate);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_tick_rate_get(unsigned long *tickRate)
+ *
+ */
+enum ioh_status ioh_1588_tick_rate_get(unsigned long *tickRate);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_interrupt_enable(
+ *					ioh1588TargetTimeCallback callBack)
+ *
+ */
+enum ioh_status
+ioh_1588_target_time_interrupt_enable(ioh1588TargetTimeCallback callBack);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_interrupt_disable(void)
+ *
+ */
+enum ioh_status ioh_1588_target_time_interrupt_disable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_poll(
+ *		unsigned long *ttmPollFlag,
+ *		struct ioh1588TimeValue *targetTime)
+ *
+ */
+enum ioh_status
+ioh_1588_target_time_poll(unsigned long *ttmPollFlag,
+			  struct ioh1588TimeValue *targetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_set(
+ *				struct ioh1588TimeValue targetTime)
+ *
+ */
+enum ioh_status ioh_1588_target_time_set(struct ioh1588TimeValue targetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_target_time_get(
+ *					struct ioh1588TimeValue *targetTime)
+ *
+ */
+enum ioh_status ioh_1588_target_time_get(struct ioh1588TimeValue *targetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_time_interrupt_enable(
+						enum ioh1588AuxMode auxMode,
+ *						ioh1588AuxTimeCallback callBack)
+ *
+ */
+enum ioh_status
+ioh_1588_aux_time_interrupt_enable(enum ioh1588AuxMode auxMode,
+				   ioh1588AuxTimeCallback callBack);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_time_interrupt_disable(
+						enum ioh1588AuxMode auxMode)
+ *
+ */
+enum ioh_status ioh_1588_aux_time_interrupt_disable(
+						enum ioh1588AuxMode auxMode);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_time_poll(
+ *				enum ioh1588AuxMode auxMode,
+ *				unsigned long *pollFlag,
+ *				struct ioh1588TimeValue *auxTime)
+ *
+ */
+enum ioh_status
+ioh_1588_aux_time_poll(enum ioh1588AuxMode auxMode,
+			unsigned long *pollFlag,
+			struct ioh1588TimeValue *auxTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_reset(void)
+ *
+ */
+enum ioh_status ioh_1588_reset(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_chnl_reset(enum ioh1588PTPPort ptpPort)
+ *
+ */
+enum ioh_status ioh_1588_chnl_reset(enum ioh1588PTPPort ptpPort);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_stats_get(struct ioh1588Stats *stats)
+ *
+ */
+enum ioh_status ioh_1588_stats_get(struct ioh1588Stats *stats);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn void ioh_1588_stats_reset(void)
+ *
+ */
+void ioh_1588_stats_reset(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn void ioh_1588_show(void)
+ *
+ */
+enum ioh_status ioh_1588_show(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_pulse_per_sec_interrupt_enable(
+ *					ioh1588PulsePerSecondCallback callBack)
+ *
+ */
+enum ioh_status
+ioh_1588_pulse_per_sec_interrupt_enable(ioh1588PulsePerSecondCallback callBack);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_pulse_per_sec_interrupt_disable(void)
+ *
+ */
+enum ioh_status ioh_1588_pulse_per_sec_interrupt_disable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_pulse_per_sec_time_get(unsigned long *ppsTime)
+ *
+ */
+enum ioh_status ioh_1588_pulse_per_sec_time_get(unsigned long *ppsTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_pulse_per_sec_time_set(unsigned long ppsTime)
+ *
+ */
+enum ioh_status ioh_1588_pulse_per_sec_time_set(unsigned long ppsTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_can_poll (
+ *			enum ioh1588PTPPort ptpPort,
+ *			struct ioh1588TimeValue *ptpTimeStamp)
+ *
+ */
+enum ioh_status ioh_1588_ptp_can_poll(enum ioh1588PTPPort ptpPort,
+				 struct ioh1588TimeValue *ptpTimeStamp);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_version_get(enum ioh1588PTPPort ptpPort,
+ *					enum ioh1588PTPVersion *ptpVersion)
+ *
+ */
+enum ioh_status
+ioh_1588_ptp_version_get(enum ioh1588PTPPort ptpPort,
+			 enum ioh1588PTPVersion *ptpVersion);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_version_set(enum ioh1588PTPPort ptpPort,
+ *					enum ioh1588PTPVersion ptpVersion)
+ *
+ */
+enum ioh_status
+ioh_1588_ptp_version_set(
+		enum ioh1588PTPPort ptpPort, \
+		enum ioh1588PTPVersion ptpVersion);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_operation_mode_set(
+ *		enum ioh1588PTPPort ptpPort,
+ *		 enum ioh1588PTPOperationMode ptpMode)
+ *
+ */
+enum ioh_status
+ioh_1588_ptp_operation_mode_set(enum ioh1588PTPPort ptpPort,
+				enum ioh1588PTPOperationMode ptpMode);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_ptp_operation_mode_get(enum ioh1588PTPPort ptpPort,
+ *					 enum ioh1588PTPOperationMode *ptpMode)
+ */
+enum ioh_status
+ioh_1588_ptp_operation_mode_get(enum ioh1588PTPPort ptpPort,
+				enum ioh1588PTPOperationMode *ptpMode);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_handler(void)
+ *
+ */
+enum ioh_status ioh_1588_handler(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_target_time_interrupt_enable(void *callBack)
+ *
+ */
+enum ioh_status ioh_1588_aux_target_time_interrupt_enable(void *callBack);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_target_time_interrupt_disable(void)
+ *
+ */
+enum ioh_status ioh_1588_aux_target_time_interrupt_disable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_target_time_poll(
+ *	unsigned long *attmPollFlag, struct ioh1588TimeValue *targetTime)
+ *
+ */
+enum ioh_status
+ioh_1588_aux_target_time_poll(unsigned long *attmPollFlag,
+			      struct ioh1588TimeValue *targetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_target_time_set(
+ *		struct ioh1588TimeValue targetTime)
+ *
+ */
+enum ioh_status ioh_1588_aux_target_time_set(
+					struct ioh1588TimeValue targetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_aux_target_time_get(
+ *					struct ioh1588TimeValue *targetTime)
+ *
+ */
+enum ioh_status ioh_1588_aux_target_time_get(
+					struct ioh1588TimeValue *stargetTime);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_disable_interrupts(void)
+ *
+ */
+enum ioh_status ioh_1588_disable_interrupts(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_interrupt_pending(unsigned long *pending)
+ *
+ */
+enum ioh_status ioh_1588_interrupt_pending(unsigned long *pending);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_eth_enable(void)
+ *
+ */
+enum ioh_status ioh_1588_eth_enable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_eth_disable(void)
+ *
+ */
+enum ioh_status ioh_1588_eth_disable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_can_enable(void)
+ *
+ */
+enum ioh_status ioh_1588_can_enable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_can_disable(void)
+ *
+ */
+enum ioh_status ioh_1588_can_disable(void);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn enum ioh_status ioh_1588_set_station_address (unsigned char *addr)
+ *
+ */
+enum ioh_status ioh_1588_set_station_address(unsigned char *addr);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ *  @fn enum ioh_status ioh_1588_get_station_address(char *addr)
+ *
+ */
+enum ioh_status ioh_1588_get_station_address(char *addr);
+
+/*! @ingroup IEEE_1588_HALLayerAPI
+ * @fn int ioh_1588_eth_can_get(void)
+ *
+ */
+int ioh_1588_eth_can_get(void);
+
+#ifdef IOH_IEEE1588_A0_A1_SAMPLE_BUG
+void ioh_1588_set_system_time_count(void);
+#endif
+
+#endif /* IOH_1588_HAL_H */
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.c topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.c
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.c	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.c	2010-03-09 10:33:42.000000000 +0900
@@ -0,0 +1,1192 @@
+ /*!
+  * @file ioh_1588_main.c
+  * @brief
+  * This file contains the definitions of the IEEE_1588_InterfaceLayer APIs
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intel EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ */
+
+#include "pch_1588_pci.h"
+#include "pch_1588_main.h"
+#include "pch_1588_hal.h"
+#include "pch_debug.h"
+#include <linux/sched.h>
+
+/* Linux functions prototypes	*/
+static int ioh_1588_open(struct inode *inode, struct file *filep);
+static int ioh_1588_release(struct inode *inode, struct file *filep);
+static int ioh_1588_ioctl(struct inode *inode, struct file *filep,
+			  unsigned int cmd, unsigned long arg);
+
+/* Linux file operations	*/
+/*! @ingroup 	IEEE_1588_Global
+ *  @var	ioh_1588_fops
+ *  @brief	The structure variable used to specify the
+ *  		driver specific functionalities to the kernel
+ *  		subsystem.
+*/
+const struct file_operations ioh_1588_fops = {
+	.owner = THIS_MODULE,
+	.open = ioh_1588_open,
+	.release = ioh_1588_release,
+	.ioctl = ioh_1588_ioctl,
+};
+
+/* For notify ioctls - values are populated from isr callbacks */
+/*! @ingroup 	IEEE_1588_Global
+ *  @var	ioh_1588_target_time
+ *  @brief 	This variable is updated from the target time reached callback
+ */
+struct ioh1588TimeValue ioh_1588_target_time;
+/*! @ingroup 	IEEE_1588_Global
+ *  @var	ioh_1588_aux_time
+ *  @brief 	This variable is updated from the Auxiliary master/slave time
+ *  		captured callback
+ */
+struct ioh1588AuxTimeIoctl ioh_1588_aux_time;
+/*! @ingroup 	IEEE_1588_Global
+ *  @var 	ioh_1588_pps_time
+ *  @brief 	This variable is updated from the Pulse per second match
+ *		 callback
+ */
+unsigned long ioh_1588_pps_time;
+
+typedef int (*ioc_func_ptr) (unsigned long cmd, char *arg);
+static int ioc_handle_notify(unsigned long cmd, char *buf);
+static int ioc_handle_clr_notify(unsigned long cmd, char *buf);
+static int ioc_handle_reset(unsigned long cmd, char *buf);
+static int ioc_handle_show(unsigned long cmd, char *buf);
+static int ioc_handle_stats(unsigned long cmd, char *buf);
+static int ioc_handle_stats_reset(unsigned long cmd, char *buf);
+static int ioc_handle_int_enable(unsigned long cmd, char *buf);
+static int ioc_handle_int_disable(unsigned long cmd, char *buf);
+static int ioc_handle_port_config(unsigned long cmd, char *buf);
+static int ioc_handle_poll(unsigned long cmd, char *buf);
+static int ioc_handle_time_set(unsigned long cmd, char *buf);
+static int ioc_handle_time_get(unsigned long cmd, char *buf);
+static int ioc_handle_tick_rate(unsigned long cmd, char *buf);
+static int ioc_handle_pps_reqt(unsigned long cmd, char *buf);
+static int ioc_handle_version_reqt(unsigned long cmd, char *buf);
+static int ioc_handle_op_mode_reqt(unsigned long cmd, char *buf);
+
+/* IOCTL command and their associated functions */
+
+/*! @ingroup 	IEEE_1588_Global
+ *  @struct 	ioh_1588_ioc_tbl
+ *  @brief 	Structure to map the ioctl command to the associated function
+ */
+static const struct ioh_1588_ioc_tbl {
+	unsigned long cmd;
+	ioc_func_ptr func;
+} ioh_1588_ioc_tbl[] = {
+	{
+	IOCTL_1588_TARG_TIME_NOTIFY, ioc_handle_notify}, {
+	IOCTL_1588_AUX_TIME_NOTIFY, ioc_handle_notify}, {
+	IOCTL_1588_PULSE_PER_SEC_NOTIFY, ioc_handle_notify}, {
+	IOCTL_1588_AUX_TARG_TIME_NOTIFY, ioc_handle_notify}, {
+	IOCTL_1588_TARG_TIME_CLR_NOTIFY, ioc_handle_clr_notify}, {
+	IOCTL_1588_AUX_TIME_CLR_NOTIFY, ioc_handle_clr_notify}, {
+	IOCTL_1588_PULSE_PER_SEC_CLR_NOTIFY, ioc_handle_clr_notify}, {
+	IOCTL_1588_AUX_TARG_TIME_CLR_NOTIFY, ioc_handle_clr_notify}, {
+	IOCTL_1588_RESET, ioc_handle_reset}, {
+	IOCTL_1588_CHNL_RESET, ioc_handle_reset},	/* for this case too */
+	{
+	IOCTL_1588_SHOW_ALL, ioc_handle_show}, {
+	IOCTL_1588_STATS_GET, ioc_handle_stats}, {
+	IOCTL_1588_STATS_RESET, ioc_handle_stats_reset}, {
+	IOCTL_1588_TARG_TIME_INTRPT_ENABLE, ioc_handle_int_enable}, {
+	IOCTL_1588_AUX_TIME_INTRPT_ENABLE, ioc_handle_int_enable}, {
+	IOCTL_1588_PULSE_PER_SEC_INTRPT_ENABLE, ioc_handle_int_enable}, {
+	IOCTL_1588_AUX_TARG_TIME_INTRPT_ENABLE, ioc_handle_int_enable}, {
+	IOCTL_1588_TARG_TIME_INTRPT_DISABLE, ioc_handle_int_disable}, {
+	IOCTL_1588_AUX_TIME_INTRPT_DISABLE, ioc_handle_int_disable}, {
+	IOCTL_1588_PULSE_PER_SEC_INTRPT_DISABLE, ioc_handle_int_disable}, {
+	IOCTL_1588_AUX_TARG_TIME_INTRPT_DISABLE, ioc_handle_int_disable}, {
+	IOCTL_1588_PORT_CONFIG_SET, ioc_handle_port_config}, {
+	IOCTL_1588_PORT_CONFIG_GET, ioc_handle_port_config}, {
+	IOCTL_1588_RX_POLL, ioc_handle_poll}, {
+	IOCTL_1588_TX_POLL, ioc_handle_poll}, {
+	IOCTL_1588_CAN_POLL, ioc_handle_poll}, {
+	IOCTL_1588_TARG_TIME_POLL, ioc_handle_poll}, {
+	IOCTL_1588_AUX_TIME_POLL, ioc_handle_poll}, {
+	IOCTL_1588_AUX_TARG_TIME_POLL, ioc_handle_poll}, {
+	IOCTL_1588_SYS_TIME_SET, ioc_handle_time_set}, {
+	IOCTL_1588_TARG_TIME_SET, ioc_handle_time_set}, {
+	IOCTL_1588_AUX_TARG_TIME_SET, ioc_handle_time_set}, {
+	IOCTL_1588_SYS_TIME_GET, ioc_handle_time_get}, {
+	IOCTL_1588_TARG_TIME_GET, ioc_handle_time_get}, {
+	IOCTL_1588_AUX_TARG_TIME_GET, ioc_handle_time_get}, {
+	IOCTL_1588_TICK_RATE_GET, ioc_handle_tick_rate}, {
+	IOCTL_1588_TICK_RATE_SET, ioc_handle_tick_rate}, {
+	IOCTL_1588_PULSE_PER_SEC_TIME_SET, ioc_handle_pps_reqt}, {
+	IOCTL_1588_PULSE_PER_SEC_TIME_GET, ioc_handle_pps_reqt}, {
+	IOCTL_1588_PORT_VERSION_SET, ioc_handle_version_reqt}, {
+	IOCTL_1588_PORT_VERSION_GET, ioc_handle_version_reqt}, {
+	IOCTL_1588_PORT_OPERATION_MODE_SET, ioc_handle_op_mode_reqt}, {
+IOCTL_1588_PORT_OPERATION_MODE_GET, ioc_handle_op_mode_reqt},};
+
+#define IOH_1588_IOC_TBL_ENTRIES	\
+			(sizeof ioh_1588_ioc_tbl / sizeof ioh_1588_ioc_tbl[0])
+
+/*! @ingroup IEEE_1588_InterfaceLayerAPI
+ * @fn int ioh_1588_open(struct inode *inode, struct file *filep)
+ * @brief 	This function is called when the driver interface is opened
+ * @remarks	This function is registered at the driver initialization
+ * 		point (module_init) and invoked when a process opens the
+ * 		IEEE 1588 device node.
+ *
+ * @param inode	[IN]  	 pointer to device inode structure
+ * @param filep [IN]	 pointer to open file structure
+ *
+ * @return	int
+ * 	- Returns 0 on success and <0 on failure
+ */
+static int ioh_1588_open(struct inode *inode, struct file *filep)
+{
+	if (ioh_1588_devp->suspend) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_open returning as device is suspended\n");
+		return -EINTR;
+	}
+	IOH_DEBUG("ioh_1588_open\n");
+
+	return 0;
+}
+
+/*! @ingroup IEEE_1588_InterfaceLayerAPI
+ * @fn int ioh_1588_release(struct inode *inode, struct file *filep)
+ * @brief 	This function is called when the driver interface is closed
+ * @remarks	This function is registered at the driver initialization
+ * 		point (module_init) and invoked when the last process
+ * 		which has an open file table entry for the device
+ * 		exits or does a close of the device file.
+ *
+ * @param inode	[IN]  	pointer to device inode structure
+ * @param filep [IN]	 pointer to open file structure
+ *
+ * @retval	int
+ * 	- Returns 0 on success and <0 on failure
+ */
+static int ioh_1588_release(struct inode *inode, struct file *filep)
+{
+	IOH_DEBUG("ioh_1588_release\n");
+
+	return 0;
+}
+
+/*! @ingroup IEEE_1588_InterfaceLayerAPI
+ * @fn int ioh_1588_ioctl(struct inode *inode, struct file *filep,
+ *		unsigned int cmd, unsigned long arg)
+ * @brief 	This function implements the ioctl interface of the driver
+ * @remarks	This function is registered at the driver initialization
+ * 		point (module_init) and invoked when a user process
+ * 		invokes the .ioctl. call on the device
+ *
+ * @param inode  [IN]		pointer to device inode structure
+ * @param filep  [IN]		pointer to open file structure
+ * @param cmd    [IN]		ioctl command
+ * @param arg    [INOUT]	argument passed to the command
+ *
+ * @retval	int
+ * 	- Returns 0 on success and <0 on failure
+ */
+static int ioh_1588_ioctl(struct inode *inode, struct file *filep,
+			  unsigned int cmd, unsigned long arg)
+{
+	char buffer[0x64];
+	unsigned int argsz;
+	int i, ret = 0;
+
+	if ((!ioh_1588_devp->initialized) || (ioh_1588_devp->suspend)) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ioctl:device is suspended OR \
+							uninitialized\n");
+		return -EINTR;
+	}
+
+	argsz = _IOC_SIZE(cmd);
+
+	if (argsz > sizeof buffer) {
+		IOH_LOG(KERN_ERR, "ioh_1588_ioctl: buffer size too small.\n");
+		return -EINVAL;
+	}
+
+	/* if data is being written to the driver */
+	if (_IOC_DIR(cmd) & _IOC_WRITE) {
+		/* get the data passed in by user */
+		if (copy_from_user(&buffer, (void *)arg, argsz)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: could not copy user space \
+								data.\n");
+			return -EFAULT;
+		}
+	}
+
+	for (i = 0; i < IOH_1588_IOC_TBL_ENTRIES; i++) {
+		if (ioh_1588_ioc_tbl[i].cmd == cmd) {
+			ret = ioh_1588_ioc_tbl[i].func(cmd, buffer);
+			break;
+		}
+	}
+	if (i >= IOH_1588_IOC_TBL_ENTRIES) {	/* did not find a match */
+		IOH_LOG(KERN_ERR, "ioh_1588_ioctl: unknown command (0x%x)\n",
+			cmd);
+		return -EINVAL;
+	}
+
+	/* if data is being read from the driver */
+	if ((ret == 0) && (_IOC_DIR(cmd) & _IOC_READ)) {
+		if (copy_to_user((void *)arg, buffer, argsz)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: could not copy data to user \
+								space.\n");
+			return -EFAULT;
+		}
+	}
+
+	return ret;
+}
+
+/* Handles all NOTIFY IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_notify (unsigned long cmd, char *buf)
+ *  @brief   	Handles all NOTIFY IOCTLs
+ *  @param   	cmd [IN]	 the IOCTL command
+ *  @param   	buf [OUT] 	 the reference to data to be returned
+ *  @retval  	int
+ *           - 0
+ *   <hr>
+ */
+static int ioc_handle_notify(unsigned long cmd, char *buf)
+{
+	unsigned int bytes_ret = 0;
+	void *param_addr = NULL;
+	wait_queue_head_t *event = NULL;
+	unsigned int eventnum = 0;
+
+	if (IOCTL_1588_AUX_TARG_TIME_NOTIFY == cmd) {
+		IOH_LOG(KERN_ERR, "ioc_handle_notify \
+			returning...[cmd = IOCTL_1588_AUX_TARG_TIME_NOTIFY]\n");
+		return -EINVAL;
+	}
+	/* request to be notified of a 1588 interrupt event Target Time */
+	else if (cmd == IOCTL_1588_TARG_TIME_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_notify cmd = IOCTL_1588_TARG_TIME_NOTIFY]\n");
+		event = &ioh_1588_devp->notify_evt[TARG_TIME_EVENT_NUM];
+		bytes_ret = sizeof(struct ioh1588TimeValue);
+		param_addr = &ioh_1588_target_time;
+		eventnum = TARG_TIME_EVENT_NUM;
+	} else if (cmd == IOCTL_1588_AUX_TIME_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_notify cmd = IOCTL_1588_AUX_TIME_NOTIFY]\n");
+		event = &ioh_1588_devp->notify_evt[AUX_TIME_EVENT_NUM];
+		bytes_ret = sizeof(struct ioh1588AuxTimeIoctl);
+		param_addr = &ioh_1588_aux_time;
+		eventnum = AUX_TIME_EVENT_NUM;
+	} else {
+		event = &ioh_1588_devp->notify_evt[PPS_EVENT_NUM];
+		bytes_ret = sizeof(unsigned long);
+		param_addr = &ioh_1588_pps_time;
+		eventnum = PPS_EVENT_NUM;
+	}
+
+	ioh_1588_devp->event_flags[eventnum] = 0;
+
+	/* wait infinitely for a 1588 interrupt event to occur */
+	IOH_DEBUG("ioc_handle_notify waiting for interrupt event...\n");
+	wait_event_interruptible(*event,
+				 ioh_1588_devp->event_flags[eventnum] == 1);
+	IOH_DEBUG("ioc_handle_notify got interrupt event...\n");
+
+	/* copy global data retreived from interrupt handler */
+	(void)memcpy((void *)&buf, (const void *)param_addr, bytes_ret);
+
+	/* reset global data to 0 */
+	(void)memset((void *)param_addr, 0, bytes_ret);
+
+	ioh_1588_devp->event_flags[eventnum] = 0;
+
+	return 0;
+}
+
+/* Handles all CLEAR NOTIFY IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_clr_notify (unsigned long cmd, char *buf)
+ *  @brief   	Handles all CLEAR NOTIFY IOCTLs
+ *  @param   	cmd [IN]	 the IOCTL command
+ *  @param   	buf 	 	 unused
+ *  @retval  int
+ *           - 0 on success
+ *           - -EINVAL for unsupported IOCTL
+ *   <hr>
+ */
+static int ioc_handle_clr_notify(unsigned long cmd, char *buf)
+{
+	unsigned int eventnum = 0;
+
+	/*
+	 * request to release a notify thread that is waiting
+	 * on a 1588 interrupt event
+	 */
+	if (cmd == IOCTL_1588_TARG_TIME_CLR_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_clr_notify cmd=\
+					IOCTL_1588_TARG_TIME_CLR_NOTIFY\n");
+		eventnum = TARG_TIME_EVENT_NUM;
+	} else if (cmd == IOCTL_1588_AUX_TIME_CLR_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_clr_notify cmd=\
+					IOCTL_1588_AUX_TIME_CLR_NOTIFY\n");
+		eventnum = AUX_TIME_EVENT_NUM;
+	} else if (cmd == IOCTL_1588_PULSE_PER_SEC_CLR_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_clr_notify cmd=\
+					IOCTL_1588_PULSE_PER_SEC_CLR_NOTIFY\n");
+		eventnum = PPS_EVENT_NUM;
+	} else if (cmd == IOCTL_1588_AUX_TARG_TIME_CLR_NOTIFY) {
+		IOH_DEBUG
+		    ("ioc_handle_clr_notify cmd=\
+					IOCTL_1588_AUX_TARG_TIME_CLR_NOTIFY\n");
+		IOH_LOG(KERN_ERR, "ioc_handle_clr_notify returning -EINVAL\n");
+		return -EINVAL;
+	}
+
+	ioh_1588_devp->event_flags[eventnum] = 1;
+
+	IOH_DEBUG("ioc_handle_clr_notify waking up blocking notify call...\n");
+	wake_up_interruptible(&ioh_1588_devp->notify_evt[eventnum]);
+	return 0;
+}
+
+/* Handles reset and channel reset IOCTLs */
+
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_reset (unsigned long cmd, char *buf)
+ *  @brief   	Handles reset and channel reset IOCTLs
+ *  @param   	cmd [IN]	 the IOCTL command
+ *  @param   	buf 	 	 unused
+ *  @retval  int
+ *           - 0 on success
+ *           - -EINVAL when hardware reset fails
+ *   <hr>
+ */
+static int ioc_handle_reset(unsigned long cmd, char *buf)
+{
+	int i = 0;
+	int ieee_mode;
+	unsigned char station[STATION_ADDR_LEN] = "00:00:00:00:00:00";
+
+	IOH_DEBUG("ioc_handle_reset: invoking ioh_1588_reset\n");
+
+	/*retrieve eth/CAN mode */
+	ieee_mode = ioh_1588_eth_can_get();
+
+	/*retrive station address */
+	ioh_1588_get_station_address(station);
+
+	/* reset the 1588 hardware */
+	if (ioh_1588_reset() != IOH_1588_SUCCESS) {
+		IOH_LOG(KERN_ERR, "ioc_handle_reset: ioh_1588_reset failed\n");
+		return -EINVAL;
+	}
+	/* Anyway, now clear all the events */
+	for (i = 0; i < NUM_EVENTS; i++)
+		ioh_1588_devp->event_flags[i] = 0;
+	/*set ETH/CAN mode */
+	if (ieee_mode & IOH_IEEE1588_ETH)
+		ioh_1588_eth_enable();
+	if (ieee_mode & IOH_IEEE1588_CAN)
+		ioh_1588_can_enable();
+
+	/*set station address */
+	if (strcmp(station, "00:00:00:00:00:00") != 0) {
+		if (ioh_1588_set_station_address(station) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_reset: could not set station \
+								address\n");
+		}
+	}
+
+	IOH_DEBUG("ioc_handle_reset: returning 0\n");
+	return 0;
+}
+
+/* Handles reset statistics IOCTL */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_stats_reset (unsigned long cmd, char *buf)
+ *  @brief   	Handles reset statistics IOCTLs
+ *  @param   	cmd 	 unused
+ *  @param   	buf  	 unused
+ *  @retval  int
+ *           - 0 on success
+ *   <hr>
+ */
+static int ioc_handle_stats_reset(unsigned long cmd, char *buf)
+{
+
+	IOH_DEBUG("ioc_handle_stats_reset: invoking ioh_1588_stats_reset\n");
+	ioh_1588_stats_reset();
+	IOH_DEBUG("ioc_handle_stats_reset: returning 0\n");
+	return 0;
+}
+
+/* Handles get statistics IOCTL */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_stats (unsigned long cmd, char *buf)
+ *  @brief   	Handles get statistics IOCTL
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [OUT]	reference to statistics retrieved
+ *  @retval  int
+ *           - 0 on success
+ *   <hr>
+ */
+static int ioc_handle_stats(unsigned long cmd, char *buf)
+{
+	IOH_DEBUG("ioc_handle_stats: invoking ioh_ioh_1588_stats_get\n");
+	if (ioh_1588_stats_get((struct ioh1588Stats *) buf) != \
+							IOH_1588_SUCCESS) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_ioctl: ioh_1588_stats_get failed\n");
+		return -EINVAL;
+	}
+	IOH_DEBUG("ioc_handle_statst: returning 0\n");
+	return 0;
+}
+
+/* Handles show all IOCTL */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_show (unsigned long cmd, char *buf)
+ *  @brief   	Handles show all IOCTL
+ *  @param   	cmd 	 unused
+ *  @param   	buf  	 unused
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  when @ref ioh_1588_show fails
+ *   <hr>
+ */
+static int ioc_handle_show(unsigned long cmd, char *buf)
+{
+	IOH_DEBUG("ioc_handle_show: invoking ioh_1588_show\n");
+	if (ioh_1588_show() != IOH_1588_SUCCESS) {
+		IOH_LOG(KERN_ERR, "ioh_1588_ioctl: ioh_1588_show failed\n");
+		return -EINVAL;
+	}
+	IOH_DEBUG("ioc_handle_show: returning 0\n");
+	return 0;
+}
+
+/* Handles all interrupt enable IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_int_enable (unsigned long cmd, char *buf)
+ *  @brief   	Handles all interrupt enable IOCTLs
+ *  @param   	cmd 	 [IN]	the IOCTL command
+ *  @param   	buf  	 [IN]   the reference to auxiliary mode
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  failed to enable interrupt
+ *   <hr>
+ */
+static int ioc_handle_int_enable(unsigned long cmd, char *buf)
+{
+	int ret = 0;
+
+	if (IOCTL_1588_TARG_TIME_INTRPT_ENABLE == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_int_enable cmd=\
+					IOCTL_1588_TARG_TIME_INTRPT_ENABLE \
+				invoking \
+				ioh_1588_target_time_interrupt_enable\n");
+		if (ioh_1588_target_time_interrupt_enable(target_time_callback)
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+				ioh_1588_target_time_interrupt_enable \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_AUX_TIME_INTRPT_ENABLE == cmd) {
+		enum ioh1588AuxMode aux_mode;
+		IOH_DEBUG
+		    ("ioc_handle_int_enable cmd=\
+					IOCTL_1588_AUX_TIME_INTRPT_ENABLE \
+				invoking ioh_1588_aux_time_interrupt_enable\n");
+
+		(void)memcpy((void *)&aux_mode, (const void *)buf,
+			     sizeof(enum ioh1588AuxMode));
+
+		if (ioh_1588_aux_time_interrupt_enable
+		    (aux_mode, auxiliary_time_callback) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+					ioh_1588_aux_time_interrupt_enable \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_PULSE_PER_SEC_INTRPT_ENABLE == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_int_enable cmd=\
+				IOCTL_1588_PULSE_PER_SEC_INTRPT_ENABLE \
+				invoking \
+				ioh_1588_pulse_per_sec_interrupt_enable\n");
+		if (ioh_1588_pulse_per_sec_interrupt_enable
+		    (pulse_per_sec_callback)
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+					ioh_1588_pps_interrupt_enable \
+					failed\n");
+			ret = -EINVAL;
+		}
+	} else {		/* IOCTL_1588_AUX_TARG_TIME_INTRPT_ENABLE */
+
+		IOH_DEBUG
+		    ("ioc_handle_int_enable cmd=\
+				OCTL_1588_AUX_TARG_TIME_INTRPT_ENABLE \
+				invoking \
+				ioh_1588_aux_target_time_interrupt_enable\n");
+		if (ioh_1588_aux_target_time_interrupt_enable((void *)NULL)
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+				ioh_1588_aux_target_time_interrupt_enable \
+				failed\n");
+			ret = -EINVAL;
+		}
+	}
+	return ret;
+}
+
+/* Handles all interrupt disable IOCTLs */
+/*! @ingroup IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_int_disable (unsigned long cmd, char *buf)
+ *  @brief   Handles all interrupt enable IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [IN]	the reference to auxiliary mode
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  failed to disable interrupt
+ *   <hr>
+ */
+static int ioc_handle_int_disable(unsigned long cmd, char *buf)
+{
+	int ret = 0;
+
+	if (IOCTL_1588_TARG_TIME_INTRPT_DISABLE == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_int_disable cmd=\
+				IOCTL_1588_TARG_TIME_INTRPT_DISABLE \
+				invoking \
+				ioh_1588_target_time_interrupt_disable\n");
+		if (ioh_1588_target_time_interrupt_disable()
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+					ioh_1588_target_time_interrupt_disable \
+					failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_AUX_TIME_INTRPT_DISABLE == cmd) {
+		enum ioh1588AuxMode aux_mode;
+		IOH_DEBUG
+		    ("ioc_handle_int_disable cmd=\
+				IOCTL_1588_AUX_TIME_INTRPT_DISABLE \
+				invoking \
+				ioh_1588_aux_time_interrupt_disable\n");
+
+		(void)memcpy((void *)&aux_mode, (const void *)buf,
+			     sizeof(enum ioh1588AuxMode));
+
+		if (ioh_1588_aux_time_interrupt_disable(aux_mode)
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+					ioh_1588_aux_time_interrupt_disable \
+					failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_PULSE_PER_SEC_INTRPT_DISABLE == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_int_disable cmd=\
+				IOCTL_1588_PULSE_PER_SEC_INTRPT_DISABLE \
+				invoking \
+				ioh_1588_pulse_per_sec_interrupt_disable\n");
+		if (ioh_1588_pulse_per_sec_interrupt_disable() !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+				ioh_1588_pulse_per_sec_interrupt_disable \
+				failed\n");
+			ret = -EINVAL;
+		}
+	} else {		/* IOCTL_1588_AUX_TARG_TIME_INTRPT_DISABLE */
+
+		IOH_DEBUG
+		    ("ioc_handle_int_disable cmd=\
+				IOCTL_1588_AUX_TARG_TIME_INTRPT_DISABLE \
+				invoking \
+				ioh_1588_aux_target_time_interrupt_disable\n");
+		if (ioh_1588_aux_target_time_interrupt_disable() !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+				ioh_1588_aux_target_time_interrupt_disable \
+				failed\n");
+			ret = -EINVAL;
+		}
+	}
+	return ret;
+}
+
+/* Handles port config set/get IOCTLs */
+/*! @ingroup IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_port_config (unsigned long cmd, char *buf)
+ *  @brief   Handles port config set/get IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [IN]	the port configuration
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  failed to set/get port configuration
+ *   <hr>
+ */
+static int ioc_handle_port_config(unsigned long cmd, char *buf)
+{
+	struct ioh1588PortCfgIoctl *port_cfg_ioctl = \
+					(struct ioh1588PortCfgIoctl *) buf;
+
+	if (IOCTL_1588_PORT_CONFIG_SET == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_port_config cmd = IOCTL_1588_PORT_CONFIG_SET \
+				invoking ioh_1588_ptp_port_config_set\n");
+
+		if (ioh_1588_ptp_port_config_set(port_cfg_ioctl->ptpPort,
+						 port_cfg_ioctl->ptpPortMode) !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_port_config_set \
+				failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_PORT_CONFIG_GET     */
+
+		IOH_DEBUG
+		    ("ioc_handle_port_config cmd = IOCTL_1588_PORT_CONFIG_GET \
+				invoking ioh_1588_ptp_port_config_get\n");
+		if (ioh_1588_ptp_port_config_get
+		    (port_cfg_ioctl->ptpPort,
+		     &port_cfg_ioctl->ptpPortMode) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_port_config_get \
+				failed\n");
+			return -EINVAL;
+		}
+	}
+	return 0;
+}
+
+/* Handles all POLL IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_poll (unsigned long cmd, char *buf)
+ *  @brief   	Handles all poll IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [IN]	the poll configuration
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_poll(unsigned long cmd, char *buf)
+{
+	int ret = 0;
+	struct ioh1588RxTxPollIoctl *poll_ioctl = \
+			(struct ioh1588RxTxPollIoctl *) buf;
+	struct ioh1588CANPollIoctl *can_poll_ioctl = \
+					(struct ioh1588CANPollIoctl *) buf;
+	struct ioh1588TimePollIoctl *time_poll_ioctl = \
+					(struct ioh1588TimePollIoctl *) buf;
+
+	if (IOCTL_1588_RX_POLL == cmd) {
+		IOH_DEBUG("ioc_handle_poll: cmd = IOCTL_1588_RX_POLL  \
+				invoking ioh_1588_ptp_rx_poll\n");
+		ret = ioh_1588_ptp_rx_poll(poll_ioctl->ptpPort,
+					   &poll_ioctl->ptpMsgData);
+		if ((ret != IOH_1588_SUCCESS) && \
+						(ret != IOH_1588_NOTIMESTAMP)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_rx_poll \
+				failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_TX_POLL == cmd) {
+		IOH_DEBUG("ioc_handle_poll: cmd = IOCTL_1588_TX_POLL \
+					invoking ioh_1588_ptp_tx_poll\n");
+		ret = ioh_1588_ptp_tx_poll(poll_ioctl->ptpPort,
+					   &poll_ioctl->ptpMsgData);
+		if ((ret != IOH_1588_SUCCESS) && \
+						(ret != IOH_1588_NOTIMESTAMP)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_tx_poll \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_CAN_POLL == cmd) {
+		IOH_DEBUG("ioc_handle_poll: cmd = IOCTL_1588_CAN_POLL \
+				invoking ioh_1588_ptp_can_poll\n");
+		ret = ioh_1588_ptp_can_poll(can_poll_ioctl->ptpPort,
+					    &can_poll_ioctl->ptpTimeStamp);
+		if ((ret != IOH_1588_SUCCESS) && \
+						(ret != IOH_1588_NOTIMESTAMP)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_can_poll \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_TARG_TIME_POLL == cmd) {
+		IOH_DEBUG("ioc_handle_poll: cmd = IOCTL_1588_TARG_TIME_POLL "
+			  "invoking ioh_1588_target_time_poll\n");
+		if (ioh_1588_target_time_poll(&time_poll_ioctl->pollFlag,
+					      &time_poll_ioctl->timeVal) !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_target_time_poll \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else if (IOCTL_1588_AUX_TIME_POLL == cmd) {
+		IOH_DEBUG("ioc_handle_poll: cmd = IOCTL_1588_AUX_TIME_POLL "
+			  "invoking ioh_1588_aux_time_poll\n");
+		if (ioh_1588_aux_time_poll(time_poll_ioctl->auxMode,
+					   &time_poll_ioctl->pollFlag,
+					   &time_poll_ioctl->timeVal)
+		    != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_aux_time_poll \
+								failed\n");
+			ret = -EINVAL;
+		}
+	} else {		/*        IOCTL_1588_AUX_TARG_TIME_POLL   */
+
+		IOH_DEBUG
+		    ("ioc_handle_poll: cmd = IOCTL_1588_AUX_TARG_TIME_POLL "
+		     "invoking ioh_1588_aux_target_time_poll\n");
+		if (ioh_1588_aux_target_time_poll
+		    (&time_poll_ioctl->pollFlag,
+		     &time_poll_ioctl->timeVal) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_aux_target_time_poll \
+								failed\n");
+			ret = -EINVAL;
+		}
+	}
+	if ((unsigned long)ret == IOH_1588_NOTIMESTAMP)
+		ret = 0;
+	return ret;
+}
+
+/* Handles all Time Set IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		 ioc_handle_time_set (unsigned long cmd, char *buf)
+ *  @brief   	Handles all Time Set IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [IN]	the time value
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_time_set(unsigned long cmd, char *buf)
+{
+	struct ioh1588TimeValue time_value;
+
+	(void)memcpy((void *)&time_value, (const void *)buf,
+		     sizeof(struct ioh1588TimeValue));
+
+	if (IOCTL_1588_SYS_TIME_SET == cmd) {
+		IOH_DEBUG("ioc_handle_time_set  cmd=IOCTL_1588_SYS_TIME_SET \
+			invoking ioh_1588_system_time_set\n");
+		if (ioh_1588_system_time_set(time_value) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_system_time_set \
+								failed\n");
+			return -EINVAL;
+		}
+	} else if (IOCTL_1588_TARG_TIME_SET == cmd) {
+		IOH_DEBUG("ioc_handle_time_set  cmd=IOCTL_1588_TARG_TIME_SET \
+			invoking ioh_1588_target_time_set\n");
+		if (ioh_1588_target_time_set(time_value) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_target_time_set \
+								failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_AUX_TARG_TIME_SET   */
+
+		IOH_DEBUG
+		    ("ioc_handle_time_set  cmd=IOCTL_1588_AUX_TARG_TIME_SET \
+			invoking ioh_1588_aux_target_time_set\n");
+		if (ioh_1588_aux_target_time_set(time_value) !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_aux_target_time_set \
+								failed\n");
+			return -EINVAL;
+		}
+	}
+	return 0;
+}
+
+/* Handles all Time Get IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_time_get (unsigned long cmd, char *buf)
+ *  @brief   	Handles all Time Get IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [OUT]	the time value
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_time_get(unsigned long cmd, char *buf)
+{
+	struct ioh1588TimeValue time_value;
+
+	if (IOCTL_1588_SYS_TIME_GET == cmd) {
+		IOH_DEBUG("ioc_handle_time_get cmd=IOCTL_1588_SYS_TIME_GET \
+				invoking ioh_1588_system_time_get\n");
+		if (ioh_1588_system_time_get(&time_value) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_system_time_get \
+								failed\n");
+			return -EINVAL;
+		}
+	} else if (IOCTL_1588_TARG_TIME_GET == cmd) {
+		IOH_DEBUG("ioc_handle_time_get cmd=IOCTL_1588_TARG_TIME_GET \
+				invoking ioh_1588_target_time_get\n");
+		if (ioh_1588_target_time_get(&time_value) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_target_time_get \
+								failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_AUX_TARG_TIME_GET   */
+
+		IOH_DEBUG
+		    ("ioc_handle_time_get cmd=IOCTL_1588_AUX_TARG_TIME_GET \
+				invoking ioh_1588_aux_target_time_get\n");
+		if (ioh_1588_aux_target_time_get(&time_value)) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_aux_target_time_set \
+								failed\n");
+			return -EINVAL;
+		}
+	}
+
+	(void)memcpy((void *)buf, (const void *)&time_value,
+		     sizeof(struct ioh1588TimeValue));
+	return 0;
+}
+
+/* Handles tick rate get/set IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_tick_rate (unsigned long cmd, char *buf)
+ *  @brief   	Handles tick rate get/set IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [OUT]	the tick rate
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_tick_rate(unsigned long cmd, char *buf)
+{
+	unsigned long val;
+
+	if (IOCTL_1588_TICK_RATE_GET == cmd) {
+		IOH_DEBUG("ioc_handle_tick_rate cmd =IOCTL_1588_TICK_RATE_GET \
+				invoking ioh_1588_tick_rate_get\n");
+		if (ioh_1588_tick_rate_get(&val) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_tick_rate_get \
+								failed\n");
+			return -EINVAL;
+		}
+
+		(void)memcpy((void *)buf, (const void *)&val, sizeof val);
+	} else {		/* (cmd == IOCTL_1588_TICK_RATE_SET)      */
+
+		IOH_DEBUG("ioc_handle_tick_rate cmd =IOCTL_1588_TICK_RATE_SET \
+				invoking ioh_1588_tick_rate_set\n");
+		(void)memcpy((void *)&val, (const void *)buf, sizeof val);
+
+		if (ioh_1588_tick_rate_set(val) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_tick_rate_set \
+								failed\n");
+			return -EINVAL;
+		}
+	}
+	return 0;
+}
+
+/* Handles pps time get/set IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_pps_reqt (unsigned long cmd, char *buf)
+ *  @brief   	Handles pps time get/set IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [INOUT]	the pulse per second value
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_pps_reqt(unsigned long cmd, char *buf)
+{
+	unsigned long val;
+
+	if (IOCTL_1588_PULSE_PER_SEC_TIME_SET == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_pps_reqt cmd=\
+			IOCTL_1588_PULSE_PER_SEC_TIME_SET \
+			invoking ioh_1588_pulse_per_sec_time_set\n");
+		(void)memcpy((void *)&val, (const void *)buf, sizeof val);
+		if (ioh_1588_pulse_per_sec_time_set(val) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+					ioh_1588_pulse_per_sec_time_set \
+								failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_PULSE_PER_SEC_TIME_GET      */
+
+		IOH_DEBUG
+		    ("ioc_handle_pps_reqt cmd=\
+			IOCTL_1588_PULSE_PER_SEC_TIME_GET \
+			invoking ioh_1588_pulse_per_sec_time_get\n");
+		if (ioh_1588_pulse_per_sec_time_get(&val) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR, "ioh_1588_ioctl: \
+				ioh_1588_pulse_per_sec_time_get failed\n");
+			return -EINVAL;
+		}
+		(void)memcpy((void *)buf, (const void *)&val, sizeof val);
+	}
+	return 0;
+}
+
+/* Handles ptp version get/set IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_version_reqt (unsigned long cmd, char *buf)
+ *  @brief   	Handles ptp version get/set IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [INOUT]the ptp version
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_version_reqt(unsigned long cmd, char *buf)
+{
+	struct ioh1588VersionIoctl *version_ioctl = \
+					(struct ioh1588VersionIoctl *) buf;
+
+	if (IOCTL_1588_PORT_VERSION_SET == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_version_reqt cmd=IOCTL_1588_PORT_VERSION_SET \
+			invoking ioh_1588_ptp_version_set\n");
+		if (ioh_1588_ptp_version_set
+		    (version_ioctl->ptpPort,
+		     version_ioctl->ptpVersion) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_version_set \
+				failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_PORT_VERSION_GET    */
+
+		IOH_DEBUG
+		    ("ioc_handle_version_reqt cmd=IOCTL_1588_PORT_VERSION_GET \
+			invoking ioh_1588_ptp_version_get\n");
+		if (ioh_1588_ptp_version_get
+		    (version_ioctl->ptpPort,
+		     &version_ioctl->ptpVersion) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: ioh_1588_ptp_version_get \
+				failed\n");
+			return -EINVAL;
+		}
+	}
+	return 0;
+}
+
+/* Handles ptp operation mode get/set IOCTLs */
+/*! @ingroup 	IEEE_1588_UtilitiesAPI
+ *  @fn		ioc_handle_op_mode_reqt (unsigned long cmd, char *buf)
+ *  @brief   	Handles ptp operation mode get/set IOCTLs
+ *  @param   cmd 	 [IN]	the IOCTL command
+ *  @param   buf  	 [INOUT]the ptp operation mode
+ *  @retval  int
+ *           - 0 		on success
+ *           - -EINVAL  on failure
+ *   <hr>
+ */
+static int ioc_handle_op_mode_reqt(unsigned long cmd, char *buf)
+{
+	struct ioh1588OperationModeIoctl *opmode_ioctl =
+	    (struct ioh1588OperationModeIoctl *) buf;
+
+	if (IOCTL_1588_PORT_OPERATION_MODE_SET == cmd) {
+		IOH_DEBUG
+		    ("ioc_handle_op_mode_reqt cmd=\
+				IOCTL_1588_PORT_OPERATION_MODE_SET \
+				invoking ioh_1588_ptp_operation_mode_set\n");
+		if (ioh_1588_ptp_operation_mode_set
+		    (opmode_ioctl->ptpPort,
+		     opmode_ioctl->ptpOpMode) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: \
+				ioh_1588_ptp_operation_mode_set failed\n");
+			return -EINVAL;
+		}
+	} else {		/* IOCTL_1588_PORT_OPERATION_MODE_GET     */
+
+		IOH_DEBUG
+		    ("ioc_handle_op_mode_reqt cmd=\
+				IOCTL_1588_PORT_OPERATION_MODE_GET \
+				invoking ioh_1588_ptp_operation_mode_get\n");
+		if (ioh_1588_ptp_operation_mode_get
+		    (opmode_ioctl->ptpPort,
+		     &opmode_ioctl->ptpOpMode) != IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_ioctl: \
+				ioh_1588_ptp_operation_mode_get failed\n");
+			return -EINVAL;
+		}
+	}
+	return 0;
+}
+
+/*! @ingroup 	InterfaceLayerNotifyRoutines
+ *  @fn 	irqreturn_t ioh_1588_isr(int irq, void *p_data)
+ *  @brief 	This function is the driver interrupt service routine.
+ *
+ * @param irq     [IN]	interrupt number
+ * @param p_data  caller data
+ *
+ * @retval	irqreturn_t
+ * 		- IRQ_HANDLED	=> interrupt handled,
+ *              - IRQ_NONE 	=> this device did not interrupt
+ */
+irqreturn_t ioh_1588_isr(int irq, void *p_data)
+{
+	unsigned long pending = 0;
+
+	(void)ioh_1588_interrupt_pending(&pending);
+	if (!pending) {
+		IOH_DEBUG("ioh_1588_isr: no pending interrupt\n");
+		return IRQ_NONE;
+	}
+
+	if (ioh_1588_handler() != IOH_1588_SUCCESS) {
+		IOH_LOG(KERN_ERR, "ioh_1588_isr: ioh_1588_handler failed\n");
+		return IRQ_NONE;
+	}
+
+	return IRQ_HANDLED;
+}
+
+/*! @ingroup 	InterfaceLayerNotifyRoutines
+ *  @fn 	void target_time_callback(struct ioh1588TimeValue tgt_time)
+ *  @brief  	The callback function that is called from the HAL
+ * 		when the target time expired interrupt occurs
+ *
+ *  @param tgt_time   target time register timestamp
+ *
+ *  @retval 	None
+ */
+void target_time_callback(struct ioh1588TimeValue tgt_time)
+{
+	/*
+	 * copy the target time value to the global value to be read by the
+	 * notify ioctl
+	 */
+	(void)memcpy((void *)&ioh_1588_target_time, (const void *)&tgt_time,
+		     sizeof(struct ioh1588TimeValue));
+
+	ioh_1588_devp->event_flags[TARG_TIME_EVENT_NUM] = 1;
+
+	IOH_DEBUG("target_time_callback: signalling the notify ioctl \
+		that the target time has expired\n");
+	/* signal the notify ioctl that the target time has expired */
+	wake_up_interruptible(&ioh_1588_devp->notify_evt[TARG_TIME_EVENT_NUM]);
+}
+
+/*! @ingroup 	InterfaceLayerNotifyRoutines
+ *  @fn 	void auxiliary_time_callback(enum ioh1588AuxMode aux_mode,
+ *		struct ioh1588TimeValue aux_time)
+ *  @brief 	The callback function that is called from the HAL
+ * 		when an aux time interrupt has occurred
+ *
+ * @param aux_mode   master, slave, or any
+ * @param aux_time   aux time register timestamp
+ *
+ * @return None
+ */
+void auxiliary_time_callback(enum ioh1588AuxMode aux_mode, \
+					struct ioh1588TimeValue aux_time)
+{
+	/*
+	 * copy the aux time value and aux mode to the global value
+	 * to be read by the notify ioctl
+	 */
+
+	ioh_1588_aux_time.auxMode = aux_mode;
+	(void)memcpy((void *)&ioh_1588_aux_time.auxTime,
+		     (const void *)&aux_time, \
+			sizeof(struct ioh1588AuxTimeIoctl));
+
+	ioh_1588_devp->event_flags[AUX_TIME_EVENT_NUM] = 1;
+
+	IOH_DEBUG("auxiliary_time_callback: signalling the notify ioctl \
+		that the auxiliary time stamp has been set\n");
+
+	/*
+	 * signal the notify ioctl that the aux timestamp has been set
+	 */
+	wake_up_interruptible(&ioh_1588_devp->notify_evt[AUX_TIME_EVENT_NUM]);
+}
+
+/*! @ingroup	InterfaceLayerNotifyRoutines
+ *  @fn 	void pulse_per_sec_callback(unsigned long pps)
+ *  @brief 	This is a callback function that will be called from the HAL
+ * 		when the pulse per second time has expired which generates an
+ *		 interrupt
+ *
+ *  @param pps	pulse per second register timestamp
+ *
+ *  @retval	None
+ */
+void pulse_per_sec_callback(unsigned long pps)
+{
+	ioh_1588_pps_time = pps;
+
+	ioh_1588_devp->event_flags[PPS_EVENT_NUM] = 1;
+
+	IOH_DEBUG("pulse_per_sec_callback: signalling the notify ioctl \
+		that the pulse per second time has expired\n");
+	/* signal the notify ioctl that the pulse per second time has expired */
+
+	wake_up_interruptible(&ioh_1588_devp->notify_evt[PPS_EVENT_NUM]);
+}
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.h topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.h
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.h	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_main.h	2010-03-09 10:22:48.000000000 +0900
@@ -0,0 +1,702 @@
+ /*!
+  * @file ioh_1588_main.h
+  * @brief
+  * This file contains the declarations of IEEE_1588_InterfaceLayer APIs
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intel EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ *
+ */
+
+#ifndef IOH_1588_MAIN_H
+#define IOH_1588_MAIN_H
+
+#ifdef __GNUC__
+#define UNUSED __attribute__ ((unused))
+#define UNUSED_ARG(x)
+#else
+#define UNUSED
+#define UNUSED_ARG(x)   (void) x
+#endif
+
+#include <linux/ioctl.h>
+
+#define TRUE 1
+#define FALSE 0
+
+/*! @defgroup   IEEE1588*/
+
+/*! @defgroup	IEEE_1588_Global
+ *  @ingroup  	IEEE1588
+ *  @brief    	This group describes the global entities within
+ *              the module.
+ *  @remarks  	This group includes all the global data structures
+ *              used within the modules. These are mainly used to
+ *              store the device related information, so that it can
+ *              be used by other functions of the modules.
+ * <hr>
+ * */
+
+/*! @defgroup   IEEE_1588_PCILayer
+ * @ingroup        IEEE1588
+ * @brief          This group describes the PCI layer interface
+ *                 functionalities.
+ * @remarks        This group contains the functions and data structures
+ *                 that are used to interface the module with PCI Layer
+ *                 subsystem of the Kernel.
+ * <hr>
+ * */
+
+/*! @defgroup   IEEE_1588_InterfaceLayer
+ * @ingroup        IEEE1588
+ * @brief          This group describes the Driver interface functionalities.
+ * @remarks        This group contains the data structures and functions used
+ *                 to interface the module driver with the kernel subsystem.
+ *                 <hr>
+ *                 */
+
+/*! @defgroup   IEEE_1588_HALLayer
+ * @ingroup        IEEE1588
+ * @brief          This group describes the hardware specific functionalities.
+ * @remarks        This group contains the functions and data structures used
+ *                 by the module to communicate with the hardware. These
+ *                 functions are device specific and designed according to the
+ *                 device specifications.
+ * <hr>
+ * */
+
+/*! @defgroup   IEEE_1588_Utilities
+ * @ingroup        IEEE1588
+ * @brief          This group describes the utility functionalities.
+ * @remarks        This group contains the functions and data structures used
+ *                 to assist the other functionalities in their operations.
+ * <hr>
+ **/
+
+/*! @defgroup   IEEE_1588_PCILayerAPI
+ * @ingroup        IEEE_1588_PCILayer
+ * @brief          This group contains the API(functions) used as the PCI
+ *                 interface between the Kernel subsystem and the module.
+ *<hr>
+ **/
+
+/*! @defgroup   IEEE_1588_PCILayerFacilitators
+ * @ingroup        IEEE_1588_PCILayer
+ * @brief          This group contains the data structures used by the PCI
+ *                 Layer APIs for their functionalities.
+ * <hr>
+ **/
+
+/*! @defgroup   IEEE_1588_InterfaceLayerAPI
+ * @ingroup        IEEE_1588_InterfaceLayer
+ * @brief          This group contains the API(functions) used as the Driver
+ *                 interface between the Kernel subsystem and the module.
+ * <hr>
+ **/
+
+/*! @defgroup   IEEE_1588_InterfaceLayerFacilitators
+ * @ingroup        IEEE_1588_InterfaceLayer
+ * @brief          This group contains the data structures used by the Driver
+ *                 interface APIs for their functionalities.
+ * <hr>
+ **/
+
+/*! @defgroup   IEEE_1588_HALLayerAPI
+ * @ingroup        IEEE_1588_HALLayer
+ * @brief          This group contains the APIs(functions) used to interact with
+ *                 the hardware. These APIs act as an interface between the
+ *                 hardware and the other driver functions.
+ * <hr>
+ **/
+
+/*! @defgroup   IEEE_1588_UtilitiesAPI
+ * @ingroup        IEEE_1588_Utilities
+ * @brief          This group contains the APIs(functions) used by other
+ *			 functions
+ *                 in their operations.
+ * <hr>
+ **/
+
+/* 1588 module ioctl command codes	*/
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ *  @def 	IOC_1588_BASE
+ * @brief 	The unique one byte data used to define
+ * 		the IOCTL commands
+ */
+#define IOC_1588_BASE 0x88
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ * @def 	IOCTL_1588_PORT_CONFIG_SET
+ * @brief 	Set the IEEE 1588 Ethernet port to Mater/Slave/All mode
+ */
+#define IOCTL_1588_PORT_CONFIG_SET \
+			_IOW(IOC_1588_BASE, 0, struct ioh1588PortCfgIoctl)
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ * @def 	IOCTL_1588_PORT_CONFIG_GET
+ * @brief 	Get the IEEE 1588 Ethernet port Configuration mode
+ */
+#define IOCTL_1588_PORT_CONFIG_GET \
+			_IOWR(IOC_1588_BASE, 1, struct ioh1588PortCfgIoctl)
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ * @def 	IOCTL_1588_RX_POLL
+ * @brief 	Poll for receive timestamp captured on the IEEE 1588 ethernet
+ *		 channel
+ */
+#define IOCTL_1588_RX_POLL _IOWR(IOC_1588_BASE, 2, struct ioh1588RxTxPollIoctl)
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ * @def 	IOCTL_1588_TX_POLL
+ * @brief 	Poll for transmit timestamp captured on the IEEE 1588 ethernet
+ *		 channel
+ */
+#define IOCTL_1588_TX_POLL _IOWR(IOC_1588_BASE, 3, struct ioh1588RxTxPollIoctl)
+
+/*! @ingroup 	IEEE_1588_InterfaceLayer
+ * @def 	IOCTL_1588_CAN_POLL
+ * @brief 	Poll for timestamp captured on the IEEE 1588 CAN channel
+ */
+#define IOCTL_1588_CAN_POLL _IOWR(IOC_1588_BASE, 4, struct ioh1588CANPollIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_SYS_TIME_GET
+ * @brief Get the IEEE 1588 system time from the module
+ */
+#define IOCTL_1588_SYS_TIME_GET _IOR(IOC_1588_BASE, 5, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_SYS_TIME_SET
+ * @brief Set the IEEE 1588 system time on the module
+ */
+#define IOCTL_1588_SYS_TIME_SET _IOW(IOC_1588_BASE, 6, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TICK_RATE_SET
+ * @brief Set the frequency scaling value used on IEEE 1588 module
+ */
+#define IOCTL_1588_TICK_RATE_SET _IOW(IOC_1588_BASE, 7, unsigned long)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TICK_RATE_GET
+ * @brief Get the frequency scaling value used on IEEE 1588 module
+ */
+#define IOCTL_1588_TICK_RATE_GET _IOR(IOC_1588_BASE, 8, unsigned long)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_INTRPT_ENABLE
+ * @brief Enable the target time reached/exceeded interrupt on IEEE 1588 module
+ */
+#define IOCTL_1588_TARG_TIME_INTRPT_ENABLE _IO(IOC_1588_BASE, 9)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_INTRPT_DISABLE
+ * @brief Disable the target time reached/exceeded interrupt on IEEE 1588 module
+ */
+#define IOCTL_1588_TARG_TIME_INTRPT_DISABLE _IO(IOC_1588_BASE, 10)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_POLL
+ * @brief Poll for the target time reached/exceeded condition on IEEE 1588
+ *	 module
+ */
+#define IOCTL_1588_TARG_TIME_POLL \
+			_IOR(IOC_1588_BASE, 11, struct ioh1588TimePollIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_SET
+ * @brief Set the target time to match on IEEE 1588 module
+ */
+#define IOCTL_1588_TARG_TIME_SET \
+				_IOW(IOC_1588_BASE, 12, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_GET
+ * @brief Get the target time currently set on IEEE 1588 module
+ */
+#define IOCTL_1588_TARG_TIME_GET \
+				_IOR(IOC_1588_BASE, 13, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TIME_INTRPT_ENABLE
+ * @brief Enable the auxiliary time captured interrupt on IEEE 1588 module
+ */
+#define IOCTL_1588_AUX_TIME_INTRPT_ENABLE \
+				_IOW(IOC_1588_BASE, 14, enum ioh1588AuxMode)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TIME_INTRPT_DISABLE
+ * @brief Disable the auxiliary time captured interrupt on IEEE 1588 module
+ */
+#define IOCTL_1588_AUX_TIME_INTRPT_DISABLE \
+				_IOW(IOC_1588_BASE, 15, enum ioh1588AuxMode)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TIME_POLL
+ * @brief Poll for the auxiliary time captured on IEEE 1588 module
+ */
+#define IOCTL_1588_AUX_TIME_POLL \
+			_IOWR(IOC_1588_BASE, 16, struct ioh1588TimePollIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_RESET
+ * @brief Reset the IEEE 1588 module
+ */
+#define IOCTL_1588_RESET _IO(IOC_1588_BASE, 17)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_CHNL_RESET
+ * @brief Reset the IEEE 1588 channel
+ */
+#define IOCTL_1588_CHNL_RESET _IOW(IOC_1588_BASE, 18, enum ioh1588PTPPort)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_STATS_GET
+ * @brief Get the timestamp captured counters from the IEEE 1588 module
+ */
+#define IOCTL_1588_STATS_GET _IOR(IOC_1588_BASE, 19, struct ioh1588Stats)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_STATS_RESET
+ * @brief Reset the timestamp captured counters maintained for IEEE 1588 module
+ */
+#define IOCTL_1588_STATS_RESET _IO(IOC_1588_BASE, 20)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_SHOW_ALL
+ * @brief Display the register contents of IEEE 1588 module
+ */
+#define IOCTL_1588_SHOW_ALL _IO(IOC_1588_BASE, 21)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_INTRPT_ENABLE
+ * @brief Enable Auxiliary target time reached interrupt - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_INTRPT_ENABLE _IO(IOC_1588_BASE, 22)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_INTRPT_DISABLE
+ * @brief Disable Auxiliary target time reached interrupt - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_INTRPT_DISABLE _IO(IOC_1588_BASE, 23)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_POLL
+ * @brief Poll for Auxiliary target time captured - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_POLL \
+			_IOR(IOC_1588_BASE, 24, struct ioh1588TimePollIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_SET
+ * @brief Set Auxiliary target time - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_SET \
+				_IOW(IOC_1588_BASE, 25, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_GET
+ * @brief Get Auxiliary target time currently set - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_GET \
+				_IOR(IOC_1588_BASE, 26, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_INTRPT_ENABLE
+ * @brief Enable Pulse per second match interrupt
+ */
+#define IOCTL_1588_PULSE_PER_SEC_INTRPT_ENABLE _IO(IOC_1588_BASE, 27)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_INTRPT_DISABLE
+ * @brief Disable Pulse per second match interrupt
+ */
+#define IOCTL_1588_PULSE_PER_SEC_INTRPT_DISABLE _IO(IOC_1588_BASE, 28)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_NOTIFY
+ * @brief Block till a target time reached interrupt occurs
+ */
+#define IOCTL_1588_TARG_TIME_NOTIFY \
+				_IOR(IOC_1588_BASE, 29, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TIME_NOTIFY
+ * @brief Block till an auxiliary time captured interrupt occurs
+ */
+#define IOCTL_1588_AUX_TIME_NOTIFY \
+			_IOR(IOC_1588_BASE, 30, struct ioh1588AuxTimeIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_NOTIFY
+ * @brief Block till an auxiliary target time reached interrupt occurs - not
+ *	 supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_NOTIFY \
+				_IOR(IOC_1588_BASE, 31, struct ioh1588TimeValue)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_NOTIFY
+ * @brief Block till a pulse per second match interrupt occurs
+ */
+#define IOCTL_1588_PULSE_PER_SEC_NOTIFY _IOR(IOC_1588_BASE, 32, unsigned long)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_TARG_TIME_CLR_NOTIFY
+ * @brief Unblock a process waiting on target time reached interrupt
+ */
+#define IOCTL_1588_TARG_TIME_CLR_NOTIFY _IO(IOC_1588_BASE, 33)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TIME_CLR_NOTIFY
+ * @brief Unblock a process waiting on auxiliary time captured interrupt
+ */
+#define IOCTL_1588_AUX_TIME_CLR_NOTIFY _IO(IOC_1588_BASE, 34)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_AUX_TARG_TIME_CLR_NOTIFY
+ * @brief Unblock a process waiting on an auxiliary target time reached
+ *	 interrupt - not supported
+ */
+#define IOCTL_1588_AUX_TARG_TIME_CLR_NOTIFY _IO(IOC_1588_BASE, 35)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_CLR_NOTIFY
+ * @brief Unblock a process waiting on a pulse per second match interrupt
+ */
+#define IOCTL_1588_PULSE_PER_SEC_CLR_NOTIFY _IO(IOC_1588_BASE, 36)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_TIME_GET
+ * @brief Get the currently specified pulse per second match time
+ */
+#define IOCTL_1588_PULSE_PER_SEC_TIME_GET _IOR(IOC_1588_BASE, 37, unsigned long)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PULSE_PER_SEC_TIME_SET
+ * @brief Specify the pulse per second match time
+ */
+#define IOCTL_1588_PULSE_PER_SEC_TIME_SET _IOW(IOC_1588_BASE, 38, unsigned long)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PORT_VERSION_SET
+ * @brief Set the PTP version to be used on the given PTP channel
+ */
+#define IOCTL_1588_PORT_VERSION_SET \
+			_IOW(IOC_1588_BASE, 39, struct ioh1588VersionIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PORT_VERSION_GET
+ * @brief Get the PTP version used on the given PTP channel
+ */
+#define IOCTL_1588_PORT_VERSION_GET \
+			_IOWR(IOC_1588_BASE, 40, struct ioh1588VersionIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PORT_OPERATION_MODE_SET
+ * @brief Set the PTP messages that are matched by the module on the given PTP
+ *	 channel
+ */
+#define IOCTL_1588_PORT_OPERATION_MODE_SET \
+		_IOW(IOC_1588_BASE, 41, struct ioh1588OperationModeIoctl)
+
+/*! @ingroup IEEE_1588_InterfaceLayer
+ * @def IOCTL_1588_PORT_OPERATION_MODE_GET
+ * @brief Get the PTP messages that are currently matched by the module on given
+ *	 PTP channel
+ */
+#define IOCTL_1588_PORT_OPERATION_MODE_GET \
+		_IOWR(IOC_1588_BASE, 42, struct ioh1588OperationModeIoctl)
+
+/**
+ * @ingroup IEEE_1588_InterfaceLayer
+ * @enum ioh1588PTPPort
+ * @brief IEEE 1588 PTP Communication Port(Channel)
+ */
+enum ioh1588PTPPort {			/* ioh1588PTPPort */
+	    IOH_1588_GBE_0_1588PTP_PORT, /**< PTP Communication Port on GBE-0 */
+	IOH_1588_CAN_0_1588PTP_PORT,	 /**< PTP Communication Port on CAN-0 */
+	IOH_1588_PORT_INVALID		/**< Invalid PTP Communication Port */
+};
+
+/**
+ * @ingroup IEEE_1588_InterfaceLayer
+ * @enum ioh1588PTPPortMode
+ * @brief PTP Port mode - Master or Slave or any
+ */
+enum ioh1588PTPPortMode {			/* ioh1588PTPPortMode */
+	    IOH_1588PTP_PORT_MASTER,   /**< Master Mode */
+	IOH_1588PTP_PORT_SLAVE,	       /**< Slave Mode */
+	IOH_1588PTP_PORT_ANYMODE,      /**< Timestamp all messages */
+	IOH_1588PTP_PORT_MODE_INVALID  /**< Invalid PTP Port Mode */
+};
+
+/**
+ * @ingroup IEEE_1588_InterfaceLayer
+ * @struct ioh1588PortCfgIoctl
+ * @brief Struct to pass port config data for ioctl call
+ */
+struct ioh1588PortCfgIoctl {		/* ioh1588PortCfgIoctl */
+	enum ioh1588PTPPort ptpPort;	/**< IEEE 1588 PTP Communication Port */
+	enum ioh1588PTPPortMode ptpPortMode;	/**< Master, Slave,
+								 or Any mode */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @enum 	ioh1588PTPMsgType
+ * @brief 	PTP Messages types that can be detected on communication port
+ */
+enum ioh1588PTPMsgType {			/* ioh1588PTPMsgType */
+	    IOH_1588PTP_MSGTYPE_SYNC, /**< PTP Sync message sent by Master or
+						 received by Slave */
+	IOH_1588PTP_MSGTYPE_DELAYREQ, /**< PTP Delay_Req message sent by Slave
+						 or received by Master */
+	IOH_1588PTP_MSGTYPE_UNKNOWN   /**< Other PTP and non-PTP message sent
+						 or received by both Master
+						 and/or Slave */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588TimeValue
+ * @brief 	Struct to hold 64 bit SystemTime and TimeStamp values
+ */
+struct ioh1588TimeValue {		/* ioh1588TimeValue */
+	unsigned long timeValueLowWord;	    /**< Lower 32 bits of time value */
+	unsigned long timeValueHighWord;    /**< Upper 32 bits of time value */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588Uuid
+ * @brief 	Struct to hold 48 bit UUID values captured in Sync or Delay_Req
+ *		 messages
+ */
+struct ioh1588Uuid{		/* ioh1588Uuid */
+	unsigned long uuidValueLowWord;	       /**< The lower 32 bits of UUID */
+	unsigned long uuidValueHighHalfword;   /**< The upper 16 bits of UUID */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588PtpMsgData
+ * @brief 	Struct for data from the PTP message returned when TimeStamp
+ *		 available
+ */
+struct ioh1588PtpMsgData{		/* ioh1588PtpMsgData */
+	enum ioh1588PTPMsgType ptpMsgType;	/**< PTP Messages type */
+	struct ioh1588TimeValue ptpTimeStamp;	/**< 64 bit TimeStamp value from
+								 PTP Message */
+	struct ioh1588Uuid ptpUuid;		/**< 48 bit UUID value from the
+								 PTP Message */
+	unsigned int ptpSequenceNumber;	/**< 16 bit Sequence Number from PTP
+								 Message */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588RxTxPollIoctl
+ * @brief 	Struct to pass PTP message data for ioctl call
+ */
+struct ioh1588RxTxPollIoctl{		/* ioh1588RxTxPollIoctl */
+	enum ioh1588PTPPort ptpPort;	/**< IEEE 1588 PTP Communication Port */
+	struct ioh1588PtpMsgData ptpMsgData;	/**< PTP message data */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588CANPollIoctl
+ * @brief 	Struct to pass CAN timestamp data for ioctl call
+ */
+struct ioh1588CANPollIoctl{		/* ioh1588CANPollIoctl */
+	enum ioh1588PTPPort ptpPort;		/**< IEEE 1588 PTP Communication
+									 Port */
+	struct ioh1588TimeValue ptpTimeStamp;	/**< CAN PTP timestamp */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @enum 	ioh1588AuxMode
+ * @brief 	Master or Slave Auxiliary Time Stamp (Snap Shot)
+ */
+enum ioh1588AuxMode{			/* ioh1588AuxMode */
+	    IOH_1588_AUXMODE_MASTER,	  /**< Auxiliary Master Mode */
+	IOH_1588_AUXMODE_SLAVE,		  /**< Auxiliary Slave Mode */
+	IOH_1588_AUXMODE_INVALID	  /**< Invalid Auxiliary Mode */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588TimePollIoctl
+ * @brief 	Struct to pass timestamp data for ioctl call
+ */
+struct ioh1588TimePollIoctl {		/* ioh1588TimePollIoctl */
+	unsigned long pollFlag;	  /**< time event */
+	struct ioh1588TimeValue timeVal; /**< timestamp value */
+	enum ioh1588AuxMode auxMode;	  /**< Master or Slave mode */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588Stats
+ * @brief 	Provides the number of times timestamps are locked for rx and tx
+ *		 PTP
+ * 		messages. The counters are reinitialized when the module is
+ *		 reset.
+ */
+struct ioh1588Stats {		/* ioh1588Stats */
+	unsigned long rxMsgs; /**< Count of timestamps for received PTP Msgs */
+	unsigned long txMsgs; /**< Count of timestamps for transmitted PTP
+									 Msgs */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588AuxTimeIoctl
+ * @brief 	Struct to pass aux time data for ioctl call
+ */
+struct ioh1588AuxTimeIoctl {		/* ioh1588AuxTimeIoctl */
+	enum ioh1588AuxMode auxMode;	  /**< aux mode: master or slave */
+	struct ioh1588TimeValue auxTime; /**< aux time snapshot */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @enum 	ioh1588PTPVersion
+ * @brief 	1588 PTP version value that can be detected on communication
+ *		 port
+ */
+enum ioh1588PTPVersion {			/* ioh1588PTPVersion */
+	    IOH_1588PTP_VERSION_0,	/**< support version 1 only */
+	IOH_1588PTP_VERSION_1,		/**< support both version 1 and version
+						 2 */
+	IOH_1588PTP_VERSION_INVALID	/**< Invalid version */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588VersionIoctl
+ * @brief 	Struct to pass timestamp data for ioctl call
+ */
+struct ioh1588VersionIoctl {		/* ioh1588VersionIoctl */
+	enum ioh1588PTPPort ptpPort;	/**< IEEE 1588 PTP Communication Port */
+	enum ioh1588PTPVersion ptpVersion;	/**< version value */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @enum 	ioh1588VersionIoctl
+ * @brief 	1588 PTP operation mode value that can be detected on
+ *		 communication port
+ */
+enum ioh1588PTPOperationMode {			/* ioh1588PTPOperationMode */
+	    IOH_1588PTP_OP_MODE_SYNC_DELAYREQ_MSGS,
+		/**< timestamp version 1 SYNC and DELAYED_REQ only */
+	IOH_1588PTP_OP_MODE_V1_ALL_MSGS,
+		/**< timestamp version 1 all messages */
+	IOH_1588PTP_OP_MODE_V1_V2_EVENT_MSGS,
+		/**< timestamp version 1 and 2 event messages only */
+	IOH_1588PTP_OP_MODE_V1_V2_ALL_MSGS,
+		/**< timestamp version 1 and 2 all messages */
+	IOH_1588PTP_OP_MODE_INVALID   /**< Invalid mode */
+};
+
+/**
+ * @ingroup 	IEEE_1588_InterfaceLayer
+ * @struct 	ioh1588OperationModeIoctl
+ * @brief 	Struct to pass timestamp data for ioctl call
+ */
+struct ioh1588OperationModeIoctl {		/* ioh1588OperationModeIoctl */
+	enum ioh1588PTPPort ptpPort;	/**< IEEE 1588 PTP Communication
+							 Port */
+	enum ioh1588PTPOperationMode ptpOpMode;	/**< IEEE 1588 operation mode */
+};
+
+/**
+ * @ingroup 	IEEE_1588_Global
+ * @enum 	ioh_status
+ * @brief 	The status as returned from the HAL
+ */
+enum ioh_status {			/* ioh_status */
+	    IOH_1588_SUCCESS,		/**< operation successful */
+	IOH_1588_INVALIDPARAM,		/**< parameter passed is invalid */
+	IOH_1588_NOTIMESTAMP,		/**< no time stamp available when
+						 polled */
+	IOH_1588_INTERRUPTMODEINUSE,	/**< while operating in interrupt mode,
+						 polling not permitted */
+	IOH_1588_FAILED,		/**< Internal error in driver */
+	IOH_1588_UNSUPPORTED,		/**< Implementation does not support
+						 this feature */
+};
+
+/* IEEE 1588 registers to save and restore on suspend/resume */
+
+/** @ingroup 	IEEE_1588_Global
+ *  @struct	ioh_1588_regs_set
+ *  @brief   	IEEE 1588 registers to save and restore on suspend/resume
+ */
+struct ioh_1588_regs_set {
+	unsigned long ts_control;
+	unsigned long ts_event;	/* not saved, cleared on restore */
+	unsigned long ts_addend;
+	unsigned long ts_accum;	/* not saved/restored */
+	unsigned long ts_test;	/* not saved/restored */
+	unsigned long ts_compare;
+	unsigned long ts_syslo;
+	unsigned long ts_syshi;
+	unsigned long ts_tgtlo;
+	unsigned long ts_tgthi;
+	unsigned long ts_asmslo;	/* not saved/restored */
+	unsigned long ts_asmshi;	/* not saved/restored */
+	unsigned long ts_ammslo;	/* not saved/restored */
+	unsigned long ts_ammshi;	/* not saved/restored */
+
+	/* Ethernet */
+	unsigned long ts_cc;
+	unsigned long ts_ce;	/* not saved, cleared on restore */
+	unsigned long ts_xslo;	/* not saved/restored */
+	unsigned long ts_xshi;	/* not saved/restored */
+	unsigned long ts_rslo;	/* not saved/restored */
+	unsigned long ts_rshi;	/* not saved/restored */
+	unsigned long ts_uuidlo;	/* not saved/restored */
+	unsigned long ts_uuidhi;	/* not saved/restored */
+
+	/* CAN */
+	unsigned long ts_cce;	/* not saved, cleared on restore */
+	unsigned long ts_cxslo;	/* not saved/restored */
+	unsigned long ts_cxshi;	/* not saved/restored */
+
+	unsigned long ts_sel;	/* Selector */
+	unsigned char ts_sti[6];	/* station addresses */
+};
+
+/* callback function prototypes */
+extern void target_time_callback(struct ioh1588TimeValue targetTime);
+extern void auxiliary_time_callback(enum ioh1588AuxMode aux_mode, \
+					struct ioh1588TimeValue auxTime);
+extern void pulse_per_sec_callback(unsigned long pps);
+#endif /* IOH_1588_H   */
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.c topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.c
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.c	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.c	2010-03-09 10:32:42.000000000 +0900
@@ -0,0 +1,700 @@
+ /*!
+  * @file ioh_1588_pci.c
+  * @brief
+  * This file contains the definitions of IEEE_1588_PCILayer APIs
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intels EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ *
+ */
+
+#include "pch_1588_pci.h"
+#include "pch_1588_hal.h"
+#include "pch_debug.h"
+
+#ifdef CONFIG_PM
+static int ioh_1588_suspend(struct pci_dev *pdev, pm_message_t state);
+static int ioh_1588_resume(struct pci_dev *pdev);
+#endif
+static int ioh_1588_probe(struct pci_dev *pdev, const struct pci_device_id *id);
+static void ioh_1588_remove(struct pci_dev *pdev);
+
+/*! @ingroup 	IEEE_1588_PCILayerFacilitators
+ *  @struct 	ioh_1588_pcidev_id
+ *  @brief 	PCI device ids supported by this driver
+ *  @remarks	This structure is used to specify the Ids of the
+ *  		devices supported by the driver module  during
+ *  		registering of the module as PCI driver.The values
+ *  		within the structure is maintained by the kernel
+ *  		subsystem to recognize the individual devices
+ *  		when they are attached to the system. Depending
+ *  		on this the corresponding device functionalities
+ *  		such as probe, remove, suspend,... are invoked.
+ *
+ *  @note	This structure contains the Vendor and device
+ *  		IDs of the device supported by the driver module.
+ *
+ *  @see
+ *  			- ioh_1588_pcidev
+ *  <hr>
+ */
+static const struct pci_device_id ioh_1588_pcidev_id[] = {
+	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_IOH_1588)},
+	{0},
+};
+
+/*	Linux pci operations	*/
+/*! @ingroup    IEEE_1588_PCILayerFacilitators
+*   @struct     ioh_1588_pcidev
+*   @brief      Store the references of PCI driver interfaces to kernel.
+*   @remarks	This strutcure is used to specify the driver specific
+*   		functionalities to the kernel subsystem. The kernel invokes
+*   		these functionalities depending on the supported device and
+*   		the events that occured.
+*
+*   @note       This structure is registered with the kernel via the call
+*               pci_register_driver from @ref ioh_1588_init
+*   @see
+*                - ioh_1588_init
+*                - ioh_1588_exit
+*<hr>
+*/
+
+static struct pci_driver ioh_1588_pcidev = {
+	.name = DRIVER_NAME,
+	.id_table = ioh_1588_pcidev_id,
+	.probe = ioh_1588_probe,
+	.remove = ioh_1588_remove,
+#ifdef CONFIG_PM
+	.suspend = ioh_1588_suspend,
+	.resume = ioh_1588_resume,
+#endif
+};
+
+/* instance of driver data structure */
+/*! @ingroup    IEEE_1588_PCILayerFacilitators
+ *  @var	ioh_1588_dev
+ *  @brief	instance of driver data structure
+ *  @see
+ *  			- ioh_1588_probe
+ *  			- ioh_1588_init
+ *  			- ioh_1588_remove
+ *  			- ioh_1588_suspend
+ *  			- ioh_1588_resume
+ *  <hr>
+ */
+static struct ioh_1588_dev ioh_1588_dev;
+
+/*! @ingroup    IEEE_1588_Global
+ *  @var	ioh_1588_devp
+ *  @brief	Pointer to driver data structure
+ *  @see
+ *  			- ioc_handle_notify
+ *  			- ioc_handle_clr_notify
+ *  			- ioc_handle_reset
+ *  			- target_time_callback
+ *  			- auxiliary_time_callback
+ *  			- pulse_per_sec_callback
+ *  			- ioh_1588_open
+ *  <hr>
+ */
+
+struct ioh_1588_dev *ioh_1588_devp = &ioh_1588_dev;
+
+/*! @ingroup    IEEE_1588_PCILayerFacilitators
+ * @struct	ioh_1588_params_
+ * @brief	structure to hold the module parameters
+ * @see
+ * 			- ioh_1588_init
+ * 			- ioh_1588_probe
+ * <hr>
+ */
+static struct ioh_1588_params_ {
+	/* module parameters */
+	int eth_enable;			/**< IEEE 1588 on ethernet interface
+					 0=Disabled 1=Enabled (default 1)*/
+	int can_enable;			/**< IEEE 1588 on CAN interface
+					 0=Disabled 1=Enabled (default 0)*/
+	int major;			/**< IEEE 1588 device major number to
+						 use (default system assigned)*/
+	unsigned char station[STATION_ADDR_LEN]; /**< IEEE 1588 station address
+					 to use - column separated hex values*/
+} ioh_1588_param = {
+1, 0, 0, "00:00:00:00:00:00"};
+
+module_param_named(eth_enable, ioh_1588_param.eth_enable, bool, 0444);
+MODULE_PARM_DESC(eth_enable,
+		 "IEEE 1588 on ethernet interface 0=Disabled 1=Enabled \
+								(default 1)");
+
+module_param_named(can_enable, ioh_1588_param.can_enable, bool, 0444);
+MODULE_PARM_DESC(can_enable,
+		 "IEEE 1588 on CAN interface 0=Disabled 1=Enabled (default 0)");
+
+module_param_named(major, ioh_1588_param.major, int, 0444);
+MODULE_PARM_DESC(major,
+		 "IEEE 1588 device major number to use (default system \
+								assigned)");
+
+module_param_string(station, ioh_1588_param.station,
+		    sizeof ioh_1588_param.station, 0444);
+MODULE_PARM_DESC(station,
+		 "IEEE 1588 station address to use - column separated hex \
+								values");
+
+/*!@ingroup IEEE_1588_PCILayerAPI
+ * @fn int ioh_1588_probe(struct pci_dev *pdev,const struct pci_device_id *id)
+ * @brief
+ * This function is called right after insmod by the PCI core. Here we enable
+ * the
+ * device to make the device's resources live. We can then read PCI CFG space
+ * and init the device.
+ *
+ * @remarks
+ * The main tasks performed by this method are:
+ * 	 		-	Allocate PCI resource required using
+ *				 request_mem_region API
+ * 				and map the memory to kernel virtual space using
+ *				 ioremap API.
+ * 			-	Enable the PCI device using pci_enable_device
+ *				 API.
+ * 			-	Initialize global variables and wait queues
+ *				 using
+ * 				init_waitqueue_head API
+ * 			-	Set the memory address to be used by the HAL
+ * 				using ioh_1588_blpl_base_address_set API
+ * 			-	Register the interrupt handler using request_irq
+ *				 API
+ * 			- 	Register the charecter driver using
+ *				 sregister_chrdev_region/
+ * 				alloc_chrdev_region APIs based on whether major
+ *				 number has been
+ * 				provided by the user or not.
+ * 			-  	Add the device to the system using the APIs
+ *				 cdev_init and
+ * 				cdev_add.
+ * 			-	If any of the above calls fail, undo the steps
+ * 				performed before the failure and return
+ *				 appropraite error
+ * 				status.
+ * 			-	Depending on the parameters passed during module
+ *				 load,
+ * 				enable/disable PTP clock synchronization control
+ *				 on GbE
+ * 				(using ioh_1588_eth_enable/ioh_1588_eth_disable
+ *				 API). /CAN
+ * 				(using ioh_1588_can_enable/ioh_1588_can_disable
+ *				 API) channel.
+ * 			-	Set the Station address as specified in the
+ *				 module
+ * 				parameter using  ioh_1588_set_station_address
+ *				  API
+ *      	-Note: For A0/A1 sample, test mode setting is enabled for
+ *       		the 64 bit System Time Register. This is a work around
+ *			 for
+ *       		the non continuous value in the 64 bit System Time
+ *			 Register
+ *       		consisting of High(32bit) / Low(32bit)
+ *
+ *
+ * @param pdev   [INOUT]	pci device structure
+ * @param id    [IN]	list of devices supported by this driver
+ *
+ * @return  int
+ * 			- 0 Success
+ * 			- -ENODEV request_mem_region or ioremap or
+ * 			   pci_enable_device or request_irq error
+ *
+ * @see
+ * 			- ioh_1588_pcidev
+ * <hr>
+ */
+
+static int __devinit
+ioh_1588_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+	int ret = 0;
+	dev_t devno;
+	int i;
+
+	UNUSED_ARG(id);
+
+	/* enable the 1588 pci device */
+	ret = pci_enable_device(pdev);
+	if (ret != 0) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe:could not enable the pci device\n");
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:pci_enable_device success\n");
+
+	ioh_1588_dev.mem_base = pci_resource_start(pdev, IO_MEM_BAR);
+
+	if (!ioh_1588_dev.mem_base) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe: could not locate IO memory address\n");
+		/*disable the pci device */
+		pci_disable_device(pdev);
+		ret = -ENODEV;
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:allocated IO memory address\n");
+
+	/* retreive the available length of the IO memory space */
+	ioh_1588_dev.mem_size = pci_resource_len(pdev, IO_MEM_BAR);
+
+	/* allocate the memory for the device registers */
+	if (!request_mem_region
+	    (ioh_1588_dev.mem_base, ioh_1588_dev.mem_size, "1588_regs")) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe: could not allocate register memory \
+								space\n");
+		ioh_1588_dev.mem_base = 0;
+		/*disable the pci device */
+		pci_disable_device(pdev);
+		ret = -EBUSY;
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:allocated register memory space\n");
+
+	/* get the virtual address to the 1588 registers */
+	ioh_1588_dev.mem_virt =
+	    ioremap(ioh_1588_dev.mem_base, ioh_1588_dev.mem_size);
+
+	if (!ioh_1588_dev.mem_virt) {
+		pci_disable_device(pdev);
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe: Could not get virtual address\n");
+		/*release memory acquired for device registers */
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		ioh_1588_dev.mem_base = 0;
+		/*disable the pci device */
+		pci_disable_device(pdev);
+		ret = -ENOMEM;
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:obtained virtual address=%p\n",
+		  ioh_1588_dev.mem_virt);
+
+	for (i = 0; i < NUM_EVENTS; i++) {
+		init_waitqueue_head(&ioh_1588_dev.notify_evt[i]);
+		ioh_1588_dev.event_flags[i] = 0;
+	}
+	IOH_DEBUG("ioh_1588_probe:initialized wait queue heads\n");
+
+	ret =
+	    ioh_1588_blpl_base_address_set((unsigned int)ioh_1588_dev.mem_virt);
+	if (ret != IOH_1588_SUCCESS) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe: ioh_1588_blpl_base_address_set \
+								failed\n");
+		/*unmap io */
+		iounmap(ioh_1588_dev.mem_virt);
+		ioh_1588_dev.mem_virt = 0;
+		/*release memory acquired for device */
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		ioh_1588_dev.mem_base = 0;
+		/*disable device */
+		pci_disable_device(pdev);
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:set base address\n");
+
+	ret = request_irq(pdev->irq, &ioh_1588_isr, IRQF_SHARED, DRIVER_NAME,
+			  &ioh_1588_dev);
+	if (ret != 0) {
+		IOH_LOG(KERN_ERR, "ioh_1588_probe: failed to get irq %d\n",
+			pdev->irq);
+		/*unmap io */
+		iounmap(ioh_1588_dev.mem_virt);
+		ioh_1588_dev.mem_virt = 0;
+		/*release memory acquired for device */
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		ioh_1588_dev.mem_base = 0;
+		/*disable device */
+		pci_disable_device(pdev);
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:registered IRQ handler successfully\n");
+
+	/*register the module */
+	if (ioh_1588_param.major != 0) {	/* user specified a major
+							 number, use it */
+		IOH_DEBUG("ioh_1588_probe:using user specified major number\n");
+		devno = MKDEV(ioh_1588_param.major, 0);
+		ret = register_chrdev_region(devno, 1, DRIVER_NAME);
+		ioh_1588_dev.devno = devno;	/* store it */
+	} else {		/* request and reserve a device number */
+
+		IOH_DEBUG
+		    ("ioh_1588_probe:dynamically allocating major number\n");
+		ret =
+		    alloc_chrdev_region(&ioh_1588_dev.devno, 0, 1, DRIVER_NAME);
+		devno = MKDEV(MAJOR(ioh_1588_dev.devno), 0);
+	}
+	if (ret < 0) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_probe: Could not register module (major %d)\
+			\n",
+			ioh_1588_param.major);
+		/*free irq */
+		free_irq(pdev->irq, &ioh_1588_dev);
+		/*unmap io */
+		iounmap(ioh_1588_dev.mem_virt);
+		ioh_1588_dev.mem_virt = 0;
+		/*release memory acquired for device */
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		ioh_1588_dev.mem_base = 0;
+		/*disable device */
+		pci_disable_device(pdev);
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe:registered the module(major %d)\n",
+		  ioh_1588_param.major);
+
+	/* init cdev struct for adding device to kernel */
+	cdev_init(&ioh_1588_dev.cdev, &ioh_1588_fops);
+	ioh_1588_dev.cdev.owner = THIS_MODULE;
+	ioh_1588_dev.cdev.ops = &ioh_1588_fops;
+
+	ret = cdev_add(&ioh_1588_dev.cdev, devno, 1);
+	if (ret != 0) {
+		IOH_LOG(KERN_ERR, "ioh_1588_probe: cdev_add failed\n");
+		/*free region allocated for char device */
+		unregister_chrdev_region(ioh_1588_dev.devno, 1);
+		/*free irq */
+		free_irq(pdev->irq, &ioh_1588_dev);
+		/*unmap io */
+		iounmap(ioh_1588_dev.mem_virt);
+		ioh_1588_dev.mem_virt = 0;
+		/*release memory acquired for device */
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		ioh_1588_dev.mem_base = 0;
+		/*disable device */
+		pci_disable_device(pdev);
+		goto exit_error;
+	}
+	IOH_DEBUG("ioh_1588_probe: cdev_add successful\n");
+
+	ioh_1588_dev.initialized = 1;
+	/* indicate success */
+	ioh_1588_dev.irq = pdev->irq;
+
+	/*reset the ieee1588 h/w */
+	ioh_1588_reset();
+
+	if (ioh_1588_param.eth_enable != 0) {	/* Enable by default */
+		IOH_DEBUG("ioh_1588_probe: invoking ioh_1588_eth_enable \
+				to enable ethernet\n");
+		(void)ioh_1588_eth_enable();
+	} else {
+		IOH_DEBUG("ioh_1588_probe: invoking ioh_1588_eth_disable \
+				to disable ethernet\n");
+		(void)ioh_1588_eth_disable();
+	}
+	if (ioh_1588_param.can_enable == 1) {	/* Enable if requested */
+		IOH_DEBUG("ioh_1588_probe: invoking ioh_1588_can_enable \
+				to enable CAN\n");
+		(void)ioh_1588_can_enable();
+	} else {
+		IOH_DEBUG("ioh_1588_probe: invoking ioh_1588_can_disable \
+				to disable CAN\n");
+		(void)ioh_1588_can_disable();
+	}
+	if (strcmp(ioh_1588_param.station, "00:00:00:00:00:00") != 0) {
+		if (ioh_1588_set_station_address(ioh_1588_param.station) !=
+		    IOH_1588_SUCCESS) {
+			IOH_LOG(KERN_ERR,
+				"ioh_1588_probe: Invalid station address \
+				parameter\n"
+				"Module loaded; But, station address not set \
+				correctly\n");
+		}
+	}
+	IOH_DEBUG("ioh_1588_probe: probe succeeded\n");
+
+	return 0;
+
+exit_error:
+
+	IOH_LOG(KERN_ERR, "ioh_1588_probe: probe failed\n");
+	return ret;
+}
+
+/*! @ingroup IEEE_1588_PCILayerAPI
+ * @fn void ioh_1588_remove(struct pci_dev *pdev)
+ * @brief
+ * This function is called when the pci driver is being unloaded from the
+ * kernel.
+ * @remarks
+ * The main tasks performed by this method are:
+ * 		- Free the interrupt line using free_irq API.
+ * 		- Disable the PCI device using pci_disable_device API.
+ * 		- Unmap the PCI memory and release the same using iounmap API.
+ * 		- Delete the char device from the system using cdev_del API.
+ * 		- Unregister the driver using unregister_chrdev_region API.
+ *
+ * @param pdev  [INOUT]	 pci device structure
+ *
+ * @return None
+ *@see
+		- ioh_1588_pcidev
+ *
+ * <hr>
+ */
+
+static void __devexit ioh_1588_remove(struct pci_dev *pdev)
+{
+	/* disable the interrupts on the 1588 hardware */
+	IOH_DEBUG("ioh_1588_remove: disabling interrupts by \
+			invoking ioh_1588_disable_interrupts\n");
+	(void)ioh_1588_disable_interrupts();
+
+	/* free the interrupt */
+	if (pdev->irq != 0) {
+		free_irq(pdev->irq, &ioh_1588_dev);
+		IOH_DEBUG("ioh_1588_remove: unregistered IRQ handler\n");
+	}
+
+	/* unmap the virtual IO memory space */
+	if (ioh_1588_dev.mem_virt != 0) {
+		iounmap(ioh_1588_dev.mem_virt);
+		IOH_DEBUG
+		    ("ioh_1588_remove: unmaped the virtual IO memory space\n");
+	}
+
+	/* release the reserved IO memory space */
+	if (ioh_1588_dev.mem_base != 0) {
+		release_mem_region(ioh_1588_dev.mem_base,
+				   ioh_1588_dev.mem_size);
+		IOH_DEBUG
+		    ("ioh_1588_remove: released the reserved IO memory \
+								space\n");
+	}
+
+	/* remove cdev struct from system */
+	cdev_del(&ioh_1588_dev.cdev);
+	IOH_DEBUG("ioh_1588_remove: removed the cdev from system\n");
+
+	unregister_chrdev_region(ioh_1588_dev.devno, 1);
+	IOH_DEBUG("ioh_1588_remove:unregisterd the module\n");
+
+	/*disable the device */
+	pci_disable_device(pdev);
+	IOH_DEBUG("ioh_1588_remove:disabled the device\n");
+
+	IOH_LOG(KERN_ERR, "ioh_1588_remove: complete\n");
+}
+
+#ifdef CONFIG_PM
+/*! @ingroup IEEE_1588_PCILayerAPI
+ * @fn int ioh_1588_suspend(struct pci_dev *pdev,pm_message_t state)
+ * @brief
+ * This function is called to suspend a device before being put into a
+ * low power state.
+ *
+ * @remarks
+ * The main tasks performed by this method are:
+ * 		- Save PCI configuration space by invoking pci_save_state API.
+ * 		- If the above step fails, return the error from pci_save_state
+ *		 API.
+ * 		- Disable the PCI device using the pci_disable_device API.
+ * 		- Put the device to new power state using pci_set_power_state
+ *		 API.
+ *
+ *
+ * @param pdev	[INOUT]	pci device structure
+ * @param state [IN]	 suspend state
+ *
+ * @return int
+ * 		- 0 on success
+ * 		- -ENOMEM	pci_save_state fails
+ *
+ * @see
+ * 		- ioh_1588_pcidev
+ * <hr>
+ * */
+static int ioh_1588_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+
+	IOH_DEBUG("ioh_1588_suspend: disabling interrupts by \
+		invoking ioh_1588_disable_interrupts\n");
+	(void)ioh_1588_disable_interrupts();
+
+	ioh_1588_dev.suspend = 1;
+
+	IOH_DEBUG("ioh_1588_suspend: saving register values by \
+		invoking ioh_1588_save_state\n");
+	ioh_1588_save_state();
+
+	pci_disable_device(pdev);
+	IOH_DEBUG("ioh_1588_suspend: disabled the device\n");
+
+	(void)pci_enable_wake(pdev, PCI_D3hot, 0);
+	IOH_DEBUG("ioh_1588_suspend: disabled PM notifications\n");
+
+	if (pci_save_state(pdev) != 0) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_suspend: could not save PCI config state\n");
+		return -ENOMEM;
+	}
+	IOH_DEBUG("ioh_1588_suspend: saved state\n");
+
+	pci_set_power_state(pdev, pci_choose_state(pdev, state));
+
+	IOH_DEBUG("ioh_1588_suspend: returning success\n");
+	return 0;
+}
+
+/*! @ingroup IEEE_1588_PCILayerAPI
+ * @fn int ioh_1588_resume(struct pci_dev *pdev)
+ * @brief
+ * This function is called to resume a device after being put into a
+ * low power state.
+ * @remarks
+ * The main tasks performed by this method are:
+ * 		- Restore the power state of the device using
+ *		 pci_set_power_state
+ * 		API.
+ * 		- Restore the PCI configuration space using pci_restore_state
+ * 		API.
+ * 		- Enable the PCI device using pci_enable_device API.
+ * 		- If pci_enable_device fails, return the error status;
+ * 		else return 0.
+ *
+ *
+ * @param pdev   [INOUT]	pci device structure
+ *
+ * @return int
+ * 		   - 0 			on success
+ * 		   - -EIO		pci_enable_device fails
+ * 		   - -EINVAL	pci_enable_device fails
+ * @see
+ * 		   - ioh_1588_pcidev
+ * <hr>
+ */
+
+static int ioh_1588_resume(struct pci_dev *pdev)
+{
+	int ret;
+
+	pci_set_power_state(pdev, PCI_D0);
+
+	ret = pci_restore_state(pdev);
+
+	if (ret != 0) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_resume: pci_restore_state failed\n");
+		return ret;
+	}
+	IOH_DEBUG("ioh_1588_resume: restored state\n");
+
+	ret = pci_enable_device(pdev);
+
+	if (ret) {
+		IOH_LOG(KERN_ERR,
+			"ioh_1588_resume: pci_enable_device failed\n");
+		return ret;
+	}
+
+	IOH_DEBUG("ioh_1588_resume: enabled device\n");
+
+	(void)pci_enable_wake(pdev, PCI_D3hot, 0);
+	IOH_DEBUG("ioh_1588_resume: disabled PM notifications\n");
+
+	IOH_DEBUG("ioh_1588_resume: restoring register values by \
+		invoking ioh_1588_restore_state\n");
+	ioh_1588_restore_state();
+
+	ioh_1588_dev.suspend = 0;
+
+	IOH_DEBUG("ioh_1588_resume: returning success\n");
+	return 0;
+}
+#endif
+
+/*! @ingroup IEEE_1588_InterfaceLayerAPI
+ * @fn void ioh_1588_exit(void)
+ * @brief 		Un-loads the IEEE 1588 PCI driver.
+ * @remarks		This function is invoked when the driver is
+ * 			unloaded. The main task performed by this
+ * 			function is un-registering the module as
+ * 			PCI driver.
+ * @param  	None
+ * @return	None
+ * <hr>
+ */
+static void __exit ioh_1588_exit(void)
+{
+
+	pci_unregister_driver(&ioh_1588_pcidev);
+
+	IOH_DEBUG("ioh_1588_exit: Driver unloaded\n");
+}
+
+/*! @ingroup IEEE_1588_InterfaceLayerAPI
+ * @fn int ioh_1588_init(void)
+ * @brief 	Initializes the driver.
+ * @remarks 	This function is the entry point for the driver.
+ * 		The main tasks performed by this method are:
+ * 		-	Register IEEE 1588 driver as a PCI driver by calling
+ *		 pci_register_driver
+ *
+ * @param None
+ *
+ * @return int
+ * 		   - 0 		on success
+ * 		   - -EBUSY	register_chrdev_region fails
+ * 		   - -ENOMEM	cdev_add/register_chrdev_region/
+ *				pci_register_driver fails
+ * 		   - -EEXIST	pci_register_driver fails
+ * 		   - -EINVAL	pci_register_driver fails
+ * <hr>
+  */
+static int __init ioh_1588_init(void)
+{
+	int ret;
+
+	(void)memset((void *)&ioh_1588_dev, 0, sizeof ioh_1588_dev);
+
+	/* register the driver with the pci core */
+	ret = pci_register_driver(&ioh_1588_pcidev);
+
+	if (ret)
+		IOH_LOG(KERN_ERR, "ioh_1588_init: pci_register failed\n");
+
+	IOH_DEBUG("ioh_1588_init: pci_register success\n");
+	return ret;
+}
+
+module_init(ioh_1588_init);
+module_exit(ioh_1588_exit);
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, ioh_1588_pcidev_id);
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.h topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.h
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.h	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_1588_pci.h	2010-03-09 05:27:48.000000000 +0900
@@ -0,0 +1,122 @@
+ /*!
+  * @file ioh_1588_pci.h
+  * @brief
+  * This file lists the declarations for IEEE_1588_PCILayer APIs.
+  * @version 0.92
+  * @section
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; version 2 of the License.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+  */
+
+/*
+ * History:
+ * modified to support Intel IOH GE IEEE 1588 hardware
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ * derived from
+ * IEEE 1588 Time Synchronization Driver for Intel EP80579
+ * Copyright(c) 2007,2008 Intel Corporation. All rights reserved.
+ *  All rights reserved.
+ *
+ */
+
+#ifndef IOH_1588_PCI_H
+#define  IOH_1588_PCI_H
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/fcntl.h>
+#include <linux/interrupt.h>
+#include <linux/uaccess.h>
+#include <linux/cdev.h>
+#include <linux/pci.h>
+
+/*! @ingroup 		IEEE_1588_Global
+ *  @def		DRIVER_NAME
+ *  @brief		Macro representing the name of this driver
+ *  <hr>
+ */
+#define DRIVER_NAME "ioh_ieee1588"
+
+/*! @ingroup    	IEEE_1588_Global
+ *  @def		STATION_ADDR_LEN
+ *  @brief		Macro representing the station address length
+ *  <hr>
+ */
+#define STATION_ADDR_LEN 20
+
+/*! @ingroup 	IEEE_1588_PCILayer
+    @def 	PCI_VENDOR_ID_IOH
+    @brief 	Outlines the PCI Vendor ID for IOH board.
+ */
+
+/*! @ingroup 	IEEE_1588_PCILayer
+    @def 	PCI_DEVICE_ID_IOH_1588
+    @brief 	Outlines the PCI Device ID for IEEE 1588 device.
+ */
+#define PCI_DEVICE_ID_IOH_1588 0x8819
+
+/*! @ingroup 		IEEE_1588_PCILayer
+ *  @def		IO_MEM_BAR
+ *  @brief		Macro representing IO memory BAR
+ *  <hr>
+ */
+#define IO_MEM_BAR 1
+
+/* enumeration of events used */
+
+/*! @ingroup    	IEEE_1588_Global
+ *  @enum		notify_event
+ *  @brief		enumeration of events used
+ *  <hr>
+ */
+enum _notify_event {
+	TARG_TIME_EVENT_NUM,
+	AUX_TIME_EVENT_NUM,
+	PPS_EVENT_NUM,
+	NUM_EVENTS
+};
+
+/* private driver data	*/
+/*! @ingroup 	IEEE_1588_Global
+ *  @struct  	ioh_1588_dev_t
+ *  @brief 	Driver private data
+ *  <hr>
+ */
+struct ioh_1588_dev {
+	dev_t devno;			/**< The device (major) number. */
+	struct cdev cdev;		/**< The cdev structure instance. */
+	void *mem_virt;			/**< The virtual memory base address.*/
+	unsigned int mem_base;		/**< The physical memory base address.*/
+	unsigned int mem_size;		/**< The memory size.		*/
+	unsigned int irq;		/**< The IRQ line of the device.*/
+	unsigned int suspend:1;		/**< The suspend flag.		*/
+	unsigned int initialized:1;	/**< The initialized flag.	*/
+	/* event variables */
+	unsigned int event_flags[NUM_EVENTS]; /**< The event variables.	*/
+	wait_queue_head_t notify_evt[NUM_EVENTS]; /**< The notify event
+								 variable.*/
+};
+
+extern struct ioh_1588_dev *ioh_1588_devp;
+extern const struct file_operations ioh_1588_fops;
+irqreturn_t ioh_1588_isr(int irq, void *p_data);
+extern void ioh_1588_save_state(void);
+extern void ioh_1588_restore_state(void);
+
+#endif /* IOH_1588_PCI_H */
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_common.h topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_common.h
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_common.h	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_common.h	2010-03-09 05:56:11.000000000 +0900
@@ -0,0 +1,146 @@
+/*!
+ * @file ioh_common.h
+ * @brief Provides the macro definitions used by all files.
+ * @version 1.0.0.0
+ * @section
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+/*
+ * History:
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ *
+ * created:
+ *	WIPRO 03/07/2009
+ * modified:
+ *	WIPRO 05/08/2009
+ *
+ */
+
+#ifndef __IOH_COMMON_H__
+#define __IOH_COMMON_H__
+
+/*! @ingroup	Global
+@def		    IOH_WRITE8
+@brief			Macro for writing 8 bit data to an io/mem address
+*/
+#define IOH_WRITE8(val, addr)   iowrite8((val), (void __iomem *)(addr))
+/*! @ingroup	Global
+@def		    IOH_LOG
+@brief			Macro for writing 16 bit data to an io/mem address
+*/
+#define IOH_WRITE16(val, addr)  iowrite16((val), (void __iomem *)(addr))
+/*! @ingroup	Global
+@def		    IOH_LOG
+@brief			Macro for writing 32 bit data to an io/mem address
+*/
+#define IOH_WRITE32(val, addr)  iowrite32((val), (void __iomem *)(addr))
+
+/*! @ingroup	Global
+@def		    IOH_READ8
+@brief			Macro for reading 8 bit data from an io/mem address
+*/
+#define IOH_READ8(addr)   ioread8((void __iomem *)(addr))
+/*! @ingroup	Global
+@def		    IOH_READ16
+@brief			Macro for reading 16 bit data from an io/mem address
+*/
+#define IOH_READ16(addr)  ioread16((void __iomem *)(addr))
+/*! @ingroup	Global
+@def		    IOH_READ32
+@brief			Macro for reading 32 bit data from an io/mem address
+*/
+#define IOH_READ32(addr)  ioread32((void __iomem *)(addr))
+/*! @ingroup	Global
+@def		    IOH_WRITE32_F
+@brief			Macro for writing 32 bit data to an io/mem address
+*/
+#define IOH_WRITE32_F(val, addr) do \
+	{ IOH_WRITE32((val), (addr)); (void)IOH_READ32((addr)); } while (0);
+
+/*! @ingroup	Global
+@def		    IOH_WRITE_BYTE
+@brief			Macro for writing 1 byte data to an io/mem address
+*/
+#define IOH_WRITE_BYTE IOH_WRITE8
+/*! @ingroup	Global
+@def		    IOH_WRITE_WORD
+@brief			Macro for writing 1 word data to an io/mem address
+*/
+#define IOH_WRITE_WORD IOH_WRITE16
+/*! @ingroup	Global
+@def		    IOH_WRITE_LONG
+@brief			Macro for writing long data to an io/mem address
+*/
+#define IOH_WRITE_LONG IOH_WRITE32
+
+/*! @ingroup	Global
+@def		    IOH_READ_BYTE
+@brief			Macro for reading 1 byte data from an io/mem address
+*/
+#define IOH_READ_BYTE  IOH_READ8
+/*! @ingroup	Global
+@def		    IOH_READ_WORD
+@brief			Macro for reading 1 word data from an io/mem address
+*/
+#define IOH_READ_WORD  IOH_READ16
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			Macro for reading long data from an io/mem address
+*/
+#define IOH_READ_LONG  IOH_READ32
+
+/* Bit Manipulation Macros */
+
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			macro to set a specified bit(mask) at the
+			specified address
+*/
+#define IOH_SET_ADDR_BIT(addr, bitmask) IOH_WRITE_LONG((IOH_READ_LONG(addr) |\
+							 (bitmask)), (addr))
+
+/*! @ingroup	Global
+@def	    IOH_READ_LONG
+@brief		macro to clear a specified bit(mask) at the specified address
+*/
+#define IOH_CLR_ADDR_BIT(addr, bitmask) IOH_WRITE_LONG((IOH_READ_LONG(addr) &\
+							 ~(bitmask)), (addr))
+
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			macro to set a specified bitmask for a variable
+*/
+#define IOH_SET_BITMSK(var, bitmask) ((var) |= (bitmask))
+
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			macro to clear a specified bitmask for a variable
+*/
+#define IOH_CLR_BITMSK(var, bitmask) ((var) &= (~(bitmask)))
+
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			macro to set a specified bit for a variable
+*/
+#define IOH_SET_BIT(var, bit) ((var) |= (1<<(bit)))
+
+/*! @ingroup	Global
+@def		    IOH_READ_LONG
+@brief			macro to clear a specified bit for a variable
+*/
+#define IOH_CLR_BIT(var, bit) ((var) &= ~(1<<(bit)))
+
+#endif
diff -urN linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_debug.h topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_debug.h
--- linux-2.6.33-rc3/drivers/char/pch_ieee1588/pch_debug.h	1970-01-01 09:00:00.000000000 +0900
+++ topcliff-2.6.33-rc3/drivers/char/pch_ieee1588/pch_debug.h	2010-03-09 05:37:47.000000000 +0900
@@ -0,0 +1,60 @@
+/*!
+ * @file ioh_debug.h
+ * @brief Provides the macro definitions used for debugging.
+ * @version 1.0.0.0
+ * @section
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+/*
+ * History:
+ * Copyright (C) 2008 OKI SEMICONDUCTOR Co., LTD.
+ * All rights reserved.
+ *
+ * created:
+ *	WIPRO 03/07/2009
+ * modified:
+ *	WIPRO 05/08/2009
+ *
+ */
+
+#ifndef __IOH_DEBUG_H__
+#define __IOH_DEBUG_H__
+
+#ifdef MODULE
+#define IOH_LOG(level, fmt, args...) printk(level "%s:" fmt "\n",\
+						 THIS_MODULE->name, ##args)
+#else
+#define IOH_LOG(level, fmt, args...) printk(level "%s:" fmt "\n" ,\
+							 __FILE__, ##args)
+#endif
+
+
+#ifdef DEBUG
+	#define IOH_DEBUG(fmt, args...) IOH_LOG(KERN_DEBUG, fmt, ##args)
+#else
+	#define IOH_DEBUG(fmt, args...)
+#endif
+
+#ifdef IOH_TRACE_ENABLED
+	#define IOH_TRACE IOH_DEBUG
+#else
+	#define IOH_TRACE(fmt, args...)
+#endif
+
+#define IOH_TRACE_ENTER IOH_TRACE("Enter %s", __func__)
+#define IOH_TRACE_EXIT 	IOH_TRACE("Exit %s", __func__)
+
+
+#endif

Places

File linux-2.6.34-pch-ieee1588.patch of Package kernel-n900-2.6.33.3-11.2.armv7l (Revision 93aa6ac4b5db14adaa32a8a230919769)

Places