switch to 2.6.38

SVN-Revision: 31546

1 files changed, 1257 insertions, 0 deletions

diff --git a/target/linux/coldfire/patches/020-Add-dual-FEC-1588-timer-support.patch b/target/linux/coldfire/patches/020-Add-dual-FEC-1588-timer-support.patch
new file mode 100644
index 0000000..43a258f
--- /dev/null
+++ b/target/linux/coldfire/patches/020-Add-dual-FEC-1588-timer-support.patch
@@ -0,0 +1,1257 @@
+From 67d56859d24864af530506c76523f0fc3c5cb502 Mon Sep 17 00:00:00 2001
+From: Alison Wang <b18965@freescale.com>
+Date: Thu, 4 Aug 2011 09:59:44 +0800
+Subject: [PATCH 20/52] Add dual FEC 1588 timer support
+
+Add Modelo dual FEC 1588 function with IXXXAT statck.
+
+Signed-off-by: Alison Wang <b18965@freescale.com>
+---
+ drivers/net/Kconfig    |    6 +
+ drivers/net/Makefile   |    3 +
+ drivers/net/fec.c      |  153 ++++++++++++-
+ drivers/net/fec.h      |   25 ++
+ drivers/net/fec_1588.c |  626 ++++++++++++++++++++++++++++++++++++++++++++++++
+ drivers/net/fec_1588.h |  195 +++++++++++++++
+ 6 files changed, 1006 insertions(+), 2 deletions(-)
+ create mode 100644 drivers/net/fec_1588.c
+ create mode 100644 drivers/net/fec_1588.h
+
+--- a/drivers/net/Kconfig
++++ b/drivers/net/Kconfig
+@@ -1958,6 +1958,12 @@ config FEC2
+ 	  Say Y here if you want to use the second built-in 10/100 Fast
+ 	  ethernet controller on some Motorola ColdFire processors.
+ 
++config FEC_1588
++        bool "Enable 1588 interface(on some ColdFire designs)"
++	depends on M5441X && FEC
++	help
++		Say Y here if 1588 function is enabled.
++
+ config FEC_548x
+ 	tristate "MCF547x/MCF548x Fast Ethernet Controller support"
+ 	depends on M547X_8X
+--- a/drivers/net/Makefile
++++ b/drivers/net/Makefile
+@@ -123,6 +123,9 @@ obj-$(CONFIG_PCMCIA_PCNET) += 8390.o
+ obj-$(CONFIG_HP100) += hp100.o
+ obj-$(CONFIG_SMC9194) += smc9194.o
+ obj-$(CONFIG_FEC) += fec.o
++ifeq ($(CONFIG_FEC_1588), y)
++obj-$(CONFIG_FEC) += fec_1588.o
++endif
+ obj-$(CONFIG_FEC_548x) += fec_m547x.o
+ obj-$(CONFIG_FEC_MPC52xx) += fec_mpc52xx.o
+ ifeq ($(CONFIG_FEC_MPC52xx_MDIO),y)
+--- a/drivers/net/fec.c
++++ b/drivers/net/fec.c
+@@ -53,6 +53,7 @@
+ #endif
+ 
+ #include "fec.h"
++#include "fec_1588.h"
+ 
+ #if defined(CONFIG_ARCH_MXC) || defined(CONFIG_SOC_IMX28)
+ #define FEC_ALIGNMENT	0xf
+@@ -135,8 +136,15 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet
+ #define FEC_ENET_RXB	((uint)0x01000000)	/* A buffer was received */
+ #define FEC_ENET_MII	((uint)0x00800000)	/* MII interrupt */
+ #define FEC_ENET_EBERR	((uint)0x00400000)	/* SDMA bus error */
++#define FEC_ENET_TS_AVAIL	((uint)0x00010000)
++#define FEC_ENET_TS_TIMER	((uint)0x00008000)
+ 
++#if defined(CONFIG_FEC_1588)
++#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII | \
++			FEC_ENET_TS_AVAIL | FEC_ENET_TS_TIMER)
++#else
+ #define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
++#endif
+ 
+ /* The FEC stores dest/src/type, data, and checksum for receive packets.
+  */
+@@ -209,6 +217,10 @@ struct fec_enet_private {
+ 	int	link;
+ 	int	full_duplex;
+ 	struct	completion mdio_done;
++#ifdef CONFIG_FEC_1588
++	struct fec_ptp_private *ptp_priv;
++	uint    ptimer_present;
++#endif
+ };
+ 
+ static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
+@@ -252,6 +264,9 @@ fec_enet_start_xmit(struct sk_buff *skb,
+ 	struct bufdesc *bdp;
+ 	void *bufaddr;
+ 	unsigned short	status;
++#ifdef CONFIG_FEC_1588
++	unsigned long estatus;
++#endif
+ 	unsigned long flags;
+ 
+ 	if (!fep->link) {
+@@ -293,6 +308,17 @@ fec_enet_start_xmit(struct sk_buff *skb,
+ 		bufaddr = fep->tx_bounce[index];
+ 	}
+ 
++#ifdef CONFIG_FEC_1588
++	if (fep->ptimer_present) {
++		if (fec_ptp_do_txstamp(skb))
++			estatus = BD_ENET_TX_TS;
++		else
++			estatus = 0;
++
++		bdp->cbd_esc = (estatus | BD_ENET_TX_INT);
++		bdp->cbd_bdu = 0;
++	}
++#endif
+ 	/*
+ 	 * Some design made an incorrect assumption on endian mode of
+ 	 * the system that it's running on. As the result, driver has to
+@@ -357,6 +383,9 @@ fec_enet_interrupt(int irq, void * dev_i
+ {
+ 	struct	net_device *dev = dev_id;
+ 	struct fec_enet_private *fep = netdev_priv(dev);
++#ifdef CONFIG_FEC_1588
++	struct fec_ptp_private *fpp = fep->ptp_priv;
++#endif
+ 	uint	int_events;
+ 	irqreturn_t ret = IRQ_NONE;
+ 
+@@ -364,6 +393,10 @@ fec_enet_interrupt(int irq, void * dev_i
+ 		int_events = readl(fep->hwp + FEC_IEVENT);
+ 		writel(int_events, fep->hwp + FEC_IEVENT);
+ 
++#ifdef CONFIG_FEC_1588
++		if (__raw_readb(MCF_DTIM1_DTER) & MCF_DTIM_DTER_REF)
++			__raw_writeb(MCF_DTIM_DTER_REF, MCF_DTIM1_DTER);
++#endif
+ 		if (int_events & FEC_ENET_RXF) {
+ 			ret = IRQ_HANDLED;
+ 			fec_enet_rx(dev);
+@@ -378,6 +411,19 @@ fec_enet_interrupt(int irq, void * dev_i
+ 			fec_enet_tx(dev);
+ 		}
+ 
++#ifdef CONFIG_FEC_1588
++		if (int_events & FEC_ENET_TS_AVAIL) {
++			ret = IRQ_HANDLED;
++			fec_ptp_store_txstamp(fep->ptp_priv);
++		}
++
++		if (int_events & FEC_ENET_TS_TIMER) {
++			ret = IRQ_HANDLED;
++			if (fep->ptimer_present)
++				fpp->prtc++;
++		}
++#endif
++
+ 		if (int_events & FEC_ENET_MII) {
+ 			ret = IRQ_HANDLED;
+ 			complete(&fep->mdio_done);
+@@ -394,6 +440,9 @@ fec_enet_tx(struct net_device *dev)
+ 	struct	fec_enet_private *fep;
+ 	struct bufdesc *bdp;
+ 	unsigned short status;
++#ifdef CONFIG_FEC_1588
++	unsigned long estatus;
++#endif
+ 	struct	sk_buff	*skb;
+ 
+ 	fep = netdev_priv(dev);
+@@ -437,6 +486,13 @@ fec_enet_tx(struct net_device *dev)
+ 		if (status & BD_ENET_TX_DEF)
+ 			dev->stats.collisions++;
+ 
++#if defined(CONFIG_FEC_1588)
++		if (fep->ptimer_present) {
++			estatus = bdp->cbd_esc;
++			if (estatus & BD_ENET_TX_TS)
++				fec_ptp_store_txstamp(fep->ptp_priv);
++		}
++#endif
+ 		/* Free the sk buffer associated with this last transmit */
+ 		dev_kfree_skb_any(skb);
+ 		fep->tx_skbuff[fep->skb_dirty] = NULL;
+@@ -470,6 +526,9 @@ static void
+ fec_enet_rx(struct net_device *dev)
+ {
+ 	struct	fec_enet_private *fep = netdev_priv(dev);
++#ifdef CONFIG_FEC_1588
++	struct fec_ptp_private *fpp = fep->ptp_priv;
++#endif
+ 	const struct platform_device_id *id_entry =
+ 				platform_get_device_id(fep->pdev);
+ 	struct bufdesc *bdp;
+@@ -554,6 +613,12 @@ fec_enet_rx(struct net_device *dev)
+ 			skb_put(skb, pkt_len - 4);	/* Make room */
+ 			skb_copy_to_linear_data(skb, data, pkt_len - 4);
+ 			skb->protocol = eth_type_trans(skb, dev);
++
++#ifdef CONFIG_FEC_1588
++			/* 1588 messeage TS handle */
++			if (fep->ptimer_present)
++				fec_ptp_store_rxstamp(fpp, skb, bdp);
++#endif
+ 			netif_rx(skb);
+ 		}
+ 
+@@ -567,6 +632,11 @@ rx_processing_done:
+ 		status |= BD_ENET_RX_EMPTY;
+ 		bdp->cbd_sc = status;
+ 
++#ifdef CONFIG_FEC_1588
++		bdp->cbd_esc = BD_ENET_RX_INT;
++		bdp->cbd_prot = 0;
++		bdp->cbd_bdu = 0;
++#endif
+ 		/* Update BD pointer to next entry */
+ 		if (status & BD_ENET_RX_WRAP)
+ 			bdp = fep->rx_bd_base;
+@@ -669,8 +739,11 @@ static void fec_enet_adjust_link(struct
+ 			fec_stop(dev);
+ 
+ 		if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
+-			writel(2, fep->hwp + FEC_ECNTRL);
+-
++#ifdef CONFIG_FEC_1588
++			writel(0x00000012, fep->hwp + FEC_ECNTRL);
++#else
++			writel(0x00000002, fep->hwp + FEC_ECNTRL);
++#endif
+ 		status_change = 1;
+ 	}
+ 
+@@ -983,6 +1056,10 @@ static int fec_enet_alloc_buffers(struct
+ 		bdp->cbd_bufaddr = dma_map_single(&dev->dev, skb->data,
+ 				FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
+ 		bdp->cbd_sc = BD_ENET_RX_EMPTY;
++
++#ifdef CONFIG_FEC_1588
++		bdp->cbd_esc = BD_ENET_RX_INT;
++#endif
+ 		bdp++;
+ 	}
+ 
+@@ -996,6 +1073,9 @@ static int fec_enet_alloc_buffers(struct
+ 
+ 		bdp->cbd_sc = 0;
+ 		bdp->cbd_bufaddr = 0;
++#ifdef CONFIG_FEC_1588
++		bdp->cbd_esc = BD_ENET_TX_INT;
++#endif
+ 		bdp++;
+ 	}
+ 
+@@ -1256,8 +1336,12 @@ fec_restart(struct net_device *dev, int
+ 		writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
+ 	}
+ 
++#ifdef CONFIG_FEC_1588
++	writel(0x7fff8000, fep->hwp + FEC_IEVENT);
++#else
+ 	/* Clear any outstanding interrupt. */
+ 	writel(0xffc00000, fep->hwp + FEC_IEVENT);
++#endif
+ 
+ 	/* Reset all multicast.	*/
+ 	writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+@@ -1342,8 +1426,25 @@ fec_restart(struct net_device *dev, int
+ #endif
+ 	}
+ 
++#ifdef CONFIG_FEC_1588
++	if (fep->ptimer_present) {
++		int ret;
++		/* Set Timer count */
++		ret = fec_ptp_start(fep->ptp_priv);
++		if (ret) {
++			fep->ptimer_present = 0;
++			writel(2, fep->hwp + FEC_ECNTRL);
++		} else {
++			val = readl(fep->hwp + FEC_ECNTRL);
++			val |= 0x00000012;
++			writel(val, fep->hwp + FEC_ECNTRL);
++		}
++	} else
++		writel(2, fep->hwp + FEC_ECNTRL);
++#else
+ 	/* And last, enable the transmit and receive processing */
+ 	writel(2, fep->hwp + FEC_ECNTRL);
++#endif
+ 	writel(0, fep->hwp + FEC_R_DES_ACTIVE);
+ 
+ 	/* Enable interrupts we wish to service */
+@@ -1367,6 +1468,10 @@ fec_stop(struct net_device *dev)
+ 	writel(1, fep->hwp + FEC_ECNTRL);
+ 	udelay(10);
+ 	writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
++#ifdef CONFIG_FEC_1588
++	if (fep->ptimer_present)
++		fec_ptp_stop(fep->ptp_priv);
++#endif
+ 	writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
+ }
+ 
+@@ -1428,6 +1533,24 @@ fec_probe(struct platform_device *pdev)
+ 		}
+ 	}
+ 
++#ifdef CONFIG_FEC_1588
++	i = (pdev->id) ? (64 + 64 + 64 + 7) : (64 + 64 + 64);
++	if (request_irq(i + 48, fec_enet_interrupt, IRQF_DISABLED,
++				"1588 TS AVAIL", ndev) != 0)
++		printk(KERN_ERR "FEC: Could not alloc FEC %x 1588 TS AVAIL "
++			"IRQ(%d)!\n", pdev->id, i + 48);
++
++	if (pdev->id == 0) {
++		printk("setup TS timer interrupt through DMA timer1\n");
++		__raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
++
++		if (request_irq(64 + 33, fec_enet_interrupt, IRQF_DISABLED,
++					"1588 TS TIMER", ndev) != 0)
++			printk(KERN_ERR "FEC: Could not alloc FEC %x 1588 TS"
++				" TIMER IRQ(%d)!\n", pdev->id, 64 + 33);
++	}
++#endif
++
+ 	fep->clk = clk_get(&pdev->dev, "fec_clk");
+ 	if (IS_ERR(fep->clk)) {
+ 		ret = PTR_ERR(fep->clk);
+@@ -1443,6 +1566,20 @@ fec_probe(struct platform_device *pdev)
+ 	if (ret)
+ 		goto failed_mii_init;
+ 
++#ifdef CONFIG_FEC_1588
++	fep->ptp_priv = kzalloc(sizeof(struct fec_ptp_private),
++					GFP_KERNEL);
++	if (fep->ptp_priv) {
++		fep->ptp_priv->hwp = fep->hwp;
++		ret = fec_ptp_init(fep->ptp_priv, pdev->id);
++		if (ret)
++			printk(KERN_ERR "IEEE1588: ptp-timer init failed\n");
++		else
++			fep->ptimer_present = 1;
++	} else
++		printk(KERN_ERR "IEEE1588: failed to malloc memory\n");
++#endif
++
+ 	/* Carrier starts down, phylib will bring it up */
+ 	netif_carrier_off(ndev);
+ 
+@@ -1454,6 +1591,12 @@ fec_probe(struct platform_device *pdev)
+ 
+ failed_register:
+ 	fec_enet_mii_remove(fep);
++#ifdef CONFIG_FEC_1588
++	if (fep->ptimer_present)
++		fec_ptp_cleanup(fep->ptp_priv);
++
++	kfree(fep->ptp_priv);
++#endif
+ failed_mii_init:
+ failed_init:
+ 	clk_disable(fep->clk);
+@@ -1485,6 +1628,12 @@ fec_drv_remove(struct platform_device *p
+ 	clk_disable(fep->clk);
+ 	clk_put(fep->clk);
+ 	iounmap((void __iomem *)ndev->base_addr);
++#ifdef CONFIG_FEC_1588
++	if (fep->ptimer_present)
++		fec_ptp_cleanup(fep->ptp_priv);
++
++	kfree(fep->ptp_priv);
++#endif
+ 	unregister_netdev(ndev);
+ 	free_netdev(ndev);
+ 	return 0;
+--- a/drivers/net/fec.h
++++ b/drivers/net/fec.h
+@@ -50,6 +50,16 @@
+ #define FEC_MIIGSK_CFGR		0x300 /* MIIGSK Configuration reg */
+ #define FEC_MIIGSK_ENR		0x308 /* MIIGSK Enable reg */
+ 
++#if defined(CONFIG_FEC_1588)
++#define FEC_ATIME_CTRL          0x400
++#define FEC_ATIME               0x404
++#define FEC_ATIME_EVT_OFFSET    0x408
++#define FEC_ATIME_EVT_PERIOD    0x40c
++#define FEC_ATIME_CORR          0x410
++#define FEC_ATIME_INC           0x414
++#define FEC_TS_TIMESTAMP        0x418
++#endif
++
+ #else
+ 
+ #define FEC_ECNTRL		0x000 /* Ethernet control reg */
+@@ -78,6 +88,9 @@
+ 
+ #endif /* CONFIG_M5272 */
+ 
++#if defined(CONFIG_FEC_1588)
++#define FEC_ENHANCED_MODE	1
++#endif
+ 
+ /*
+  *	Define the buffer descriptor structure.
+@@ -93,6 +106,14 @@ struct bufdesc {
+ 	unsigned short	cbd_sc;			/* Control and status info */
+ 	unsigned short	cbd_datlen;		/* Data length */
+ 	unsigned long	cbd_bufaddr;		/* Buffer address */
++
++#ifdef FEC_ENHANCED_MODE
++	unsigned long cbd_esc;
++	unsigned long cbd_prot;
++	unsigned long cbd_bdu;
++	unsigned long ts;
++	unsigned short res0[4];
++#endif
+ };
+ #endif
+ 
+@@ -128,6 +149,7 @@ struct bufdesc {
+ #define BD_ENET_RX_OV           ((ushort)0x0002)
+ #define BD_ENET_RX_CL           ((ushort)0x0001)
+ #define BD_ENET_RX_STATS        ((ushort)0x013f)        /* All status bits */
++#define BD_ENET_RX_INT          0x00800000
+ 
+ /* Buffer descriptor control/status used by Ethernet transmit.
+ */
+@@ -146,6 +168,9 @@ struct bufdesc {
+ #define BD_ENET_TX_CSL          ((ushort)0x0001)
+ #define BD_ENET_TX_STATS        ((ushort)0x03ff)        /* All status bits */
+ 
++#define BD_ENET_TX_TS           0x20000000
++#define BD_ENET_TX_INT          0x40000000
++#define BD_ENET_TX_BDU          0x80000000
+ 
+ /****************************************************************************/
+ #endif /* FEC_H */
+--- /dev/null
++++ b/drivers/net/fec_1588.c
+@@ -0,0 +1,626 @@
++/*
++ * drivers/net/fec_1588.c
++ *
++ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
++ * Copyright (C) 2009 IXXAT Automation, GmbH
++ *
++ * FEC Ethernet Driver -- IEEE 1588 interface functionality
++ *
++ * 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; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * 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.,
++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ */
++
++#include <linux/io.h>
++#include <linux/device.h>
++#include <linux/fs.h>
++#include <linux/vmalloc.h>
++#include <linux/spinlock.h>
++#include <linux/ip.h>
++#include <linux/udp.h>
++#include <asm/mcf5441x_ccm.h>
++#include <asm/mcf5441x_dtim.h>
++#include <asm/mcfsim.h>
++#include "fec_1588.h"
++
++static DECLARE_WAIT_QUEUE_HEAD(ptp_rx_ts_wait);
++#define PTP_GET_RX_TIMEOUT      (HZ/10)
++#define COLDFIRE_DTIM1_INT	(64+32+1)
++
++static struct fec_ptp_private *ptp_private[2];
++
++static void init_DTIM1_for_1588(struct fec_ptp_private *priv)
++{
++	printk(KERN_INFO "Initializing DTIM1 for 1588 TS timer\n");
++
++	__raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
++
++	/*Enable 1588*/
++
++	__raw_writeb(MCF_DTIM_DTXMR_1588EN, MCF_DTIM1_DTXMR);
++
++	/*Compare to the 1588 timerbase*/
++	__raw_writel(FEC_T_PERIOD_ONE_SEC - FEC_T_INC_40MHZ, MCF_DTIM1_DTRR);
++
++	__raw_writeb(MCF_DTIM_DTER_REF, MCF_DTIM1_DTER);
++
++	MCF_GPIO_PAR_TIMER = (MCF_GPIO_PAR_TIMER & MCF_GPIO_PAR_TIMER_T1IN_MASK)
++				| MCF_GPIO_PAR_TIMER_T1IN_T1OUT;
++}
++
++static void start_DTIM1(void)
++{
++	__raw_writew(MCF_DTIM_DTMR_RST_EN | MCF_DTIM_DTMR_ORRI |
++			MCF_DTIM_DTMR_OM, MCF_DTIM1_DTMR);
++}
++
++static void stop_DTIM1(void)
++{
++	__raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
++}
++
++/* Alloc the ring resource */
++static int fec_ptp_init_circ(struct circ_buf *ptp_buf)
++{
++	ptp_buf->buf = vmalloc(DEFAULT_PTP_RX_BUF_SZ *
++					sizeof(struct fec_ptp_data_t));
++
++	if (!ptp_buf->buf)
++		return 1;
++	ptp_buf->head = 0;
++	ptp_buf->tail = 0;
++
++	return 0;
++}
++
++static inline int fec_ptp_calc_index(int size, int curr_index, int offset)
++{
++	return (curr_index + offset) % size;
++}
++
++static int fec_ptp_is_empty(struct circ_buf *buf)
++{
++	return (buf->head == buf->tail);
++}
++
++static int fec_ptp_nelems(struct circ_buf *buf)
++{
++	const int front = buf->head;
++	const int end = buf->tail;
++	const int size = DEFAULT_PTP_RX_BUF_SZ;
++	int n_items;
++
++	if (end > front)
++		n_items = end - front;
++	else if (end < front)
++		n_items = size - (front - end);
++	else
++		n_items = 0;
++
++	return n_items;
++}
++
++static int fec_ptp_is_full(struct circ_buf *buf)
++{
++	if (fec_ptp_nelems(buf) ==
++				(DEFAULT_PTP_RX_BUF_SZ - 1))
++		return 1;
++	else
++		return 0;
++}
++
++static int fec_ptp_insert(struct circ_buf *ptp_buf,
++			  struct fec_ptp_data_t *data,
++			  struct fec_ptp_private *priv)
++{
++	struct fec_ptp_data_t *tmp;
++
++	if (fec_ptp_is_full(ptp_buf))
++		return 1;
++
++	spin_lock(&priv->ptp_lock);
++	tmp = (struct fec_ptp_data_t *)(ptp_buf->buf) + ptp_buf->tail;
++
++	tmp->key = data->key;
++	tmp->ts_time.sec = data->ts_time.sec;
++	tmp->ts_time.nsec = data->ts_time.nsec;
++
++	ptp_buf->tail = fec_ptp_calc_index(DEFAULT_PTP_RX_BUF_SZ,
++					ptp_buf->tail, 1);
++	spin_unlock(&priv->ptp_lock);
++
++	return 0;
++}
++
++static int fec_ptp_find_and_remove(struct circ_buf *ptp_buf,
++				   int key,
++				   struct fec_ptp_data_t *data,
++				   struct fec_ptp_private *priv)
++{
++	int i;
++	int size = DEFAULT_PTP_RX_BUF_SZ;
++	int end = ptp_buf->tail;
++	unsigned long flags;
++	struct fec_ptp_data_t *tmp;
++
++	if (fec_ptp_is_empty(ptp_buf))
++		return 1;
++
++	i = ptp_buf->head;
++	while (i != end) {
++		tmp = (struct fec_ptp_data_t *)(ptp_buf->buf) + i;
++		if (tmp->key == key)
++			break;
++		i = fec_ptp_calc_index(size, i, 1);
++	}
++
++	spin_lock_irqsave(&priv->ptp_lock, flags);
++	if (i == end) {
++		ptp_buf->head = end;
++		spin_unlock_irqrestore(&priv->ptp_lock, flags);
++		return 1;
++	}
++
++	data->ts_time.sec = tmp->ts_time.sec;
++	data->ts_time.nsec = tmp->ts_time.nsec;
++
++	ptp_buf->head = fec_ptp_calc_index(size, i, 1);
++	spin_unlock_irqrestore(&priv->ptp_lock, flags);
++
++	return 0;
++}
++
++/* 1588 Module intialization */
++int fec_ptp_start(struct fec_ptp_private *priv)
++{
++	struct fec_ptp_private *fpp = priv;
++
++	MCF_CCM_MISCCR3 = 0x0000;
++
++	init_DTIM1_for_1588(priv);
++
++	/* Select 1588 Timer source and enable module for starting Tmr Clock */
++	fec_writel(FEC_T_CTRL_RESTART, fpp->hwp + FEC_ATIME_CTRL);
++	fec_writel(FEC_T_INC_40MHZ << FEC_T_INC_OFFSET,
++			fpp->hwp + FEC_ATIME_INC);
++	fec_writel(FEC_T_PERIOD_ONE_SEC, fpp->hwp + FEC_ATIME_EVT_PERIOD);
++	/* start counter */
++	fec_writel(FEC_T_CTRL_PERIOD_RST | FEC_T_CTRL_ENABLE |
++		FEC_T_CTRL_PINPER, fpp->hwp + FEC_ATIME_CTRL);
++
++	start_DTIM1();
++
++	return 0;
++}
++
++/* Cleanup routine for 1588 module.
++ * When PTP is disabled this routing is called */
++void fec_ptp_stop(struct fec_ptp_private *priv)
++{
++	struct fec_ptp_private *fpp = priv;
++
++	fec_writel(0, fpp->hwp + FEC_ATIME_CTRL);
++	fec_writel(FEC_T_CTRL_RESTART, fpp->hwp + FEC_ATIME_CTRL);
++	stop_DTIM1();
++}
++
++static void fec_get_curr_cnt(struct fec_ptp_private *priv,
++			struct ptp_rtc_time *curr_time)
++{
++	u32 tempval;
++
++	fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
++	fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
++	curr_time->rtc_time.nsec = fec_readl(priv->hwp + FEC_ATIME);
++	curr_time->rtc_time.sec = priv->prtc;
++
++	fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
++	tempval = fec_readl(priv->hwp + FEC_ATIME);
++	if (tempval < curr_time->rtc_time.nsec) {
++		curr_time->rtc_time.nsec = tempval;
++		curr_time->rtc_time.sec = priv->prtc;
++	}
++}
++
++/* Set the 1588 timer counter registers */
++static void fec_set_1588cnt(struct fec_ptp_private *priv,
++			struct ptp_rtc_time *fec_time)
++{
++	u32 tempval;
++	unsigned long flags;
++
++	spin_lock_irqsave(&priv->cnt_lock, flags);
++
++	priv->prtc = fec_time->rtc_time.sec;
++
++	tempval = fec_time->rtc_time.nsec;
++	fec_writel(tempval, priv->hwp + FEC_ATIME);
++	spin_unlock_irqrestore(&priv->cnt_lock, flags);
++}
++
++/* Set the BD to ptp */
++int fec_ptp_do_txstamp(struct sk_buff *skb)
++{
++	struct iphdr *iph;
++	struct udphdr *udph;
++
++	if (skb->len > 44) {
++		/* Check if port is 319 for PTP Event, and check for UDP */
++		iph = ip_hdr(skb);
++		if (iph == NULL || iph->protocol != FEC_PACKET_TYPE_UDP)
++			return 0;
++
++		udph = udp_hdr(skb);
++		if (udph != NULL && ntohs(udph->source) == 319)
++			return 1;
++	}
++
++	return 0;
++}
++
++void fec_ptp_store_txstamp(struct fec_ptp_private *priv)
++{
++	struct fec_ptp_private *fpp = priv;
++	unsigned int reg;
++
++	reg = fec_readl(fpp->hwp + FEC_TS_TIMESTAMP);
++	fpp->txstamp.nsec = reg;
++	fpp->txstamp.sec = fpp->prtc;
++}
++
++void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
++			   struct sk_buff *skb,
++			   struct bufdesc *bdp)
++{
++	int msg_type, seq_id, control;
++	struct fec_ptp_data_t tmp_rx_time;
++	struct fec_ptp_private *fpp = priv;
++	struct iphdr *iph;
++	struct udphdr *udph;
++
++	/* Check for UDP, and Check if port is 319 for PTP Event */
++	iph = (struct iphdr *)(skb->data + FEC_PTP_IP_OFFS);
++	if (iph->protocol != FEC_PACKET_TYPE_UDP)
++		return;
++
++	udph = (struct udphdr *)(skb->data + FEC_PTP_UDP_OFFS);
++	if (ntohs(udph->source) != 319)
++		return;
++
++	seq_id = *((u16 *)(skb->data + FEC_PTP_SEQ_ID_OFFS));
++	control = *((u8 *)(skb->data + FEC_PTP_CTRL_OFFS));
++
++	tmp_rx_time.key = ntohs(seq_id);
++	tmp_rx_time.ts_time.sec = fpp->prtc;
++	tmp_rx_time.ts_time.nsec = bdp->ts;
++
++	switch (control) {
++
++	case PTP_MSG_SYNC:
++		fec_ptp_insert(&(priv->rx_time_sync), &tmp_rx_time, priv);
++		break;
++
++	case PTP_MSG_DEL_REQ:
++		fec_ptp_insert(&(priv->rx_time_del_req), &tmp_rx_time, priv);
++		break;
++
++	/* clear transportSpecific field*/
++	case PTP_MSG_ALL_OTHER:
++		msg_type = (*((u8 *)(skb->data +
++				FEC_PTP_MSG_TYPE_OFFS))) & 0x0F;
++		switch (msg_type) {
++		case PTP_MSG_P_DEL_REQ:
++			fec_ptp_insert(&(priv->rx_time_pdel_req),
++						&tmp_rx_time, priv);
++			break;
++		case PTP_MSG_P_DEL_RESP:
++			fec_ptp_insert(&(priv->rx_time_pdel_resp),
++					&tmp_rx_time, priv);
++			break;
++		default:
++			break;
++		}
++		break;
++	default:
++		break;
++	}
++
++	wake_up_interruptible(&ptp_rx_ts_wait);
++}
++
++static void fec_get_tx_timestamp(struct fec_ptp_private *priv,
++				 struct ptp_time *tx_time)
++{
++	tx_time->sec = priv->txstamp.sec;
++	tx_time->nsec = priv->txstamp.nsec;
++}
++
++static uint8_t fec_get_rx_time(struct fec_ptp_private *priv,
++			       struct ptp_ts_data *pts,
++			       struct ptp_time *rx_time)
++{
++	struct fec_ptp_data_t tmp;
++	int key, flag;
++	u8 mode;
++
++	key = pts->seq_id;
++	mode = pts->message_type;
++	switch (mode) {
++	case PTP_MSG_SYNC:
++		flag = fec_ptp_find_and_remove(&(priv->rx_time_sync),
++						key, &tmp, priv);
++		break;
++	case PTP_MSG_DEL_REQ:
++		flag = fec_ptp_find_and_remove(&(priv->rx_time_del_req),
++						key, &tmp, priv);
++		break;
++
++	case PTP_MSG_P_DEL_REQ:
++		flag = fec_ptp_find_and_remove(&(priv->rx_time_pdel_req),
++						key, &tmp, priv);
++		break;
++	case PTP_MSG_P_DEL_RESP:
++		flag = fec_ptp_find_and_remove(&(priv->rx_time_pdel_resp),
++						key, &tmp, priv);
++		break;
++
++	default:
++		flag = 1;
++		printk(KERN_ERR "ERROR\n");
++		break;
++	}
++
++	if (!flag) {
++		rx_time->sec = tmp.ts_time.sec;
++		rx_time->nsec = tmp.ts_time.nsec;
++		return 0;
++	} else {
++		wait_event_interruptible_timeout(ptp_rx_ts_wait, 0,
++					PTP_GET_RX_TIMEOUT);
++
++		switch (mode) {
++		case PTP_MSG_SYNC:
++			flag = fec_ptp_find_and_remove(&(priv->rx_time_sync),
++				key, &tmp, priv);
++			break;
++		case PTP_MSG_DEL_REQ:
++			flag = fec_ptp_find_and_remove(
++				&(priv->rx_time_del_req), key, &tmp, priv);
++			break;
++		case PTP_MSG_P_DEL_REQ:
++			flag = fec_ptp_find_and_remove(
++				&(priv->rx_time_pdel_req), key, &tmp, priv);
++			break;
++		case PTP_MSG_P_DEL_RESP:
++			flag = fec_ptp_find_and_remove(
++				&(priv->rx_time_pdel_resp), key, &tmp, priv);
++			break;
++		}
++
++		if (flag == 0) {
++			rx_time->sec = tmp.ts_time.sec;
++			rx_time->nsec = tmp.ts_time.nsec;
++			return 0;
++		}
++
++		return -1;
++	}
++}
++
++static void fec_handle_ptpdrift(
++	struct ptp_set_comp *comp,
++	struct ptp_time_correct *ptc)
++{
++	u32 ndrift;
++	u32 i;
++	u32 tmp, tmp_ns, tmp_prid;
++	u32 min_ns, min_prid, miss_ns;
++
++	ndrift = comp->drift;
++	if (ndrift == 0) {
++		ptc->corr_inc = 0;
++		ptc->corr_period = 0;
++		return;
++	}
++
++	if (ndrift >= FEC_ATIME_40MHZ) {
++		ptc->corr_inc = (u32)(ndrift / FEC_ATIME_40MHZ);
++		ptc->corr_period = 1;
++		return;
++	}
++
++	min_ns = 1;
++	tmp = FEC_ATIME_40MHZ % ndrift;
++	tmp_prid = (u32)(FEC_ATIME_40MHZ / ndrift);
++	min_prid = tmp_prid;
++	miss_ns = tmp / tmp_prid;
++	for (i = 2; i <= FEC_T_INC_40MHZ; i++) {
++		tmp = (FEC_ATIME_40MHZ * i) % ndrift;
++		tmp_prid = (FEC_ATIME_40MHZ * i) / ndrift;
++		tmp_ns = tmp / tmp_prid;
++		if (tmp_ns <= 10) {
++			min_ns = i;
++			min_prid = tmp_prid;
++			break;
++		}
++
++		if (tmp_ns < miss_ns) {
++			min_ns = i;
++			min_prid = tmp_prid;
++			miss_ns = tmp_ns;
++		}
++	}
++
++	ptc->corr_inc = min_ns;
++	ptc->corr_period = min_prid;
++}
++
++static void fec_set_drift(struct fec_ptp_private *priv,
++	struct ptp_set_comp *comp)
++{
++	struct ptp_time_correct tc;
++	struct fec_ptp_private *fpp = priv;
++	u32 tmp, corr_ns;
++
++	fec_handle_ptpdrift(comp, &tc);
++	if (tc.corr_inc == 0)
++		return;
++
++	if (comp->o_ops == TRUE)
++		corr_ns = FEC_T_INC_40MHZ + tc.corr_inc;
++	else
++		corr_ns = FEC_T_INC_40MHZ - tc.corr_inc;
++
++	tmp = fec_readl(fpp->hwp + FEC_ATIME_INC) & FEC_T_INC_MASK;
++	tmp |= corr_ns << FEC_T_INC_CORR_OFFSET;
++	fec_writel(tmp, fpp->hwp + FEC_ATIME_INC);
++
++	fec_writel(tc.corr_period, fpp->hwp + FEC_ATIME_CORR);
++}
++
++static int ptp_open(struct inode *inode, struct file *file)
++{
++	return 0;
++}
++
++static int ptp_release(struct inode *inode, struct file *file)
++{
++	return 0;
++}
++
++static long ptp_unlocked_ioctl(
++	struct file *file,
++	unsigned int cmd,
++	unsigned long arg)
++{
++	struct ptp_rtc_time *cnt;
++	struct ptp_rtc_time curr_time;
++	struct ptp_time rx_time, tx_time;
++	struct ptp_ts_data *p_ts;
++	struct ptp_set_comp *p_comp;
++	struct fec_ptp_private *priv;
++	struct inode *inode = file->f_mapping->host;
++	unsigned int minor = MINOR(inode->i_rdev);
++	long retval = 0;
++
++	priv = (struct fec_ptp_private *) ptp_private[minor];
++	switch (cmd) {
++	case PTP_GET_RX_TIMESTAMP:
++		p_ts = (struct ptp_ts_data *)arg;
++		retval = fec_get_rx_time(priv, p_ts, &rx_time);
++		if (retval == 0)
++			copy_to_user((void __user *)(&(p_ts->ts)), &rx_time,
++					sizeof(rx_time));
++		break;
++	case PTP_GET_TX_TIMESTAMP:
++		p_ts = (struct ptp_ts_data *)arg;
++		fec_get_tx_timestamp(priv, &tx_time);
++		copy_to_user((void __user *)(&(p_ts->ts)), &tx_time,
++				sizeof(tx_time));
++		break;
++	case PTP_GET_CURRENT_TIME:
++		fec_get_curr_cnt(priv, &curr_time);
++		copy_to_user((void __user *)arg, &curr_time, sizeof(curr_time));
++		break;
++	case PTP_SET_RTC_TIME:
++		cnt = (struct ptp_rtc_time *)arg;
++		fec_set_1588cnt(priv, cnt);
++		break;
++	case PTP_FLUSH_TIMESTAMP:
++		/* reset sync buffer */
++		priv->rx_time_sync.head = 0;
++		priv->rx_time_sync.tail = 0;
++		/* reset delay_req buffer */
++		priv->rx_time_del_req.head = 0;
++		priv->rx_time_del_req.tail = 0;
++		/* reset pdelay_req buffer */
++		priv->rx_time_pdel_req.head = 0;
++		priv->rx_time_pdel_req.tail = 0;
++		/* reset pdelay_resp buffer */
++		priv->rx_time_pdel_resp.head = 0;
++		priv->rx_time_pdel_resp.tail = 0;
++		break;
++	case PTP_SET_COMPENSATION:
++		p_comp = (struct ptp_set_comp *)arg;
++		fec_set_drift(priv, p_comp);
++		break;
++	case PTP_GET_ORIG_COMP:
++		((struct ptp_get_comp *)arg)->dw_origcomp = FEC_PTP_ORIG_COMP;
++		break;
++	default:
++		return -EINVAL;
++	}
++	return retval;
++}
++
++static const struct file_operations ptp_fops = {
++	.owner	= THIS_MODULE,
++	.llseek	= NULL,
++	.read	= NULL,
++	.write	= NULL,
++	.unlocked_ioctl	= ptp_unlocked_ioctl,
++	.open	= ptp_open,
++	.release = ptp_release,
++};
++
++static int init_ptp(void)
++{
++	if (register_chrdev(PTP_MAJOR, "ptp", &ptp_fops))
++		printk(KERN_ERR "Unable to register PTP deivce as char\n");
++
++	return 0;
++}
++
++static void ptp_free(void)
++{
++	/*unregister the PTP device*/
++	unregister_chrdev(PTP_MAJOR, "ptp");
++}
++
++
++
++/*
++ * Resource required for accessing 1588 Timer Registers.
++ */
++int fec_ptp_init(struct fec_ptp_private *priv, int id)
++{
++	fec_ptp_init_circ(&(priv->rx_time_sync));
++	fec_ptp_init_circ(&(priv->rx_time_del_req));
++	fec_ptp_init_circ(&(priv->rx_time_pdel_req));
++	fec_ptp_init_circ(&(priv->rx_time_pdel_resp));
++
++	spin_lock_init(&priv->ptp_lock);
++	spin_lock_init(&priv->cnt_lock);
++	ptp_private[id] = priv;
++	if (id == 0)
++		init_ptp();
++	return 0;
++}
++EXPORT_SYMBOL(fec_ptp_init);
++
++void fec_ptp_cleanup(struct fec_ptp_private *priv)
++{
++
++	if (priv->rx_time_sync.buf)
++		vfree(priv->rx_time_sync.buf);
++	if (priv->rx_time_del_req.buf)
++		vfree(priv->rx_time_del_req.buf);
++	if (priv->rx_time_pdel_req.buf)
++		vfree(priv->rx_time_pdel_req.buf);
++	if (priv->rx_time_pdel_resp.buf)
++		vfree(priv->rx_time_pdel_resp.buf);
++
++	ptp_free();
++}
++EXPORT_SYMBOL(fec_ptp_cleanup);
+--- /dev/null
++++ b/drivers/net/fec_1588.h
+@@ -0,0 +1,195 @@
++/*
++ * drivers/net/fec_1588.h
++ *
++ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
++ *
++ * 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; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * 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.,
++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ */
++
++#ifndef FEC_1588_H
++#define FEC_1588_H
++
++#include <linux/circ_buf.h>
++#include "fec.h"
++
++#define fec_readl(addr) \
++	({ unsigned int __v = (*(volatile unsigned int *) (addr)); __v; })
++
++#define fec_writel(b, addr) (void)((*(volatile unsigned int *) (addr)) = (b))
++
++#define FALSE			0
++#define TRUE			1
++
++/* FEC 1588 register bits */
++#define FEC_T_CTRL_CAPTURE		0x00000800
++#define FEC_T_CTRL_RESTART		0x00000200
++#define FEC_T_CTRL_PERIOD_RST		0x00000010
++#define FEC_T_CTRL_PINPER		0x00000080
++#define FEC_T_CTRL_ENABLE		0x00000001
++
++#define FEC_T_INC_MASK			0x0000007f
++#define FEC_T_INC_OFFSET		0
++#define FEC_T_INC_CORR_MASK		0x00007f00
++#define FEC_T_INC_CORR_OFFSET		8
++
++#define FEC_T_INC_40MHZ			8
++#define FEC_ATIME_40MHZ			125000000
++
++#define FEC_T_PERIOD_ONE_SEC		0x3B9ACA00
++
++/* IEEE 1588 definition */
++#define FEC_ECNTRL_TS_EN	0x10
++#define PTP_MAJOR		232	/*the temporary major number
++						 *used by PTP driver, the major
++						 *number 232~239 is unassigned*/
++
++#define DEFAULT_PTP_RX_BUF_SZ		2048
++#define PTP_MSG_SYNC			0x0
++#define PTP_MSG_DEL_REQ			0x1
++#define PTP_MSG_P_DEL_REQ		0x2
++#define PTP_MSG_P_DEL_RESP		0x3
++#define PTP_MSG_DEL_RESP		0x4
++#define PTP_MSG_ALL_OTHER		0x5
++
++#define PTP_GET_TX_TIMESTAMP		0x1
++#define PTP_GET_RX_TIMESTAMP		0x9
++#define PTP_SET_RTC_TIME		0x3
++#define PTP_SET_COMPENSATION		0x4
++#define PTP_GET_CURRENT_TIME		0x5
++#define PTP_FLUSH_TIMESTAMP		0x6
++#define PTP_ADJ_ADDEND			0x7
++#define PTP_GET_ORIG_COMP		0x8
++#define PTP_GET_ADDEND			0xB
++#define PTP_GET_RX_TIMESTAMP_PDELAY_REQ		0xC
++#define PTP_GET_RX_TIMESTAMP_PDELAY_RESP	0xD
++
++#define FEC_PTP_DOMAIN_DLFT		0xe0000181
++#define FEC_PTP_IP_OFFS			0x0
++#define FEC_PTP_UDP_OFFS		0x14
++#define FEC_PTP_MSG_TYPE_OFFS		0x1C
++#define FEC_PTP_SEQ_ID_OFFS		0x3A
++#define FEC_PTP_COR_NS			0x24
++#define FEC_PTP_CTRL_OFFS		0x3C
++#define FEC_PACKET_TYPE_UDP		0x11
++
++#define FEC_PTP_ORIG_COMP		0x15555
++
++/* PTP standard time representation structure */
++struct ptp_time {
++	u64 sec;	/* seconds */
++	u32 nsec;	/* nanoseconds */
++};
++
++/* Structure for PTP Time Stamp */
++struct fec_ptp_data_t {
++	int		key;
++	struct ptp_time	ts_time;
++};
++
++/* interface for PTP driver command GET_TX_TIME */
++struct ptp_ts_data {
++	/* PTP version */
++	u8 version;
++	/* PTP source port ID */
++	u8 spid[10];
++	/* PTP sequence ID */
++	u16 seq_id;
++	/* PTP message type */
++	u8 message_type;
++	/* PTP timestamp */
++	struct ptp_time ts;
++};
++
++/* interface for PTP driver command SET_RTC_TIME/GET_CURRENT_TIME */
++struct ptp_rtc_time {
++	struct ptp_time rtc_time;
++};
++
++/* interface for PTP driver command SET_COMPENSATION */
++struct ptp_set_comp {
++	u32 drift;
++	u32 o_ops;
++};
++
++/* interface for PTP driver command GET_ORIG_COMP */
++struct ptp_get_comp {
++	/* the initial compensation value */
++	u32 dw_origcomp;
++	/* the minimum compensation value */
++	u32 dw_mincomp;
++	/*the max compensation value*/
++	u32 dw_maxcomp;
++	/*the min drift applying min compensation value in ppm*/
++	u32 dw_mindrift;
++	/*the max drift applying max compensation value in ppm*/
++	u32 dw_maxdrift;
++};
++
++struct ptp_time_correct {
++	u32 corr_period;
++	u32 corr_inc;
++};
++
++/* PTP message version */
++#define PTP_1588_MSG_VER_1	1
++#define PTP_1588_MSG_VER_2	2
++
++struct fec_ptp_private {
++	void __iomem *hwp;
++
++	struct	circ_buf rx_time_sync;
++	struct	circ_buf rx_time_del_req;
++	struct	circ_buf rx_time_pdel_req;
++	struct	circ_buf rx_time_pdel_resp;
++	spinlock_t ptp_lock;
++	spinlock_t cnt_lock;
++
++	u64	prtc;
++	struct ptp_time	txstamp;
++};
++
++#ifdef CONFIG_FEC_1588
++extern int fec_ptp_init(struct fec_ptp_private *priv, int id);
++extern void fec_ptp_cleanup(struct fec_ptp_private *priv);
++extern int fec_ptp_start(struct fec_ptp_private *priv);
++extern void fec_ptp_stop(struct fec_ptp_private *priv);
++extern int fec_ptp_do_txstamp(struct sk_buff *skb);
++extern void fec_ptp_store_txstamp(struct fec_ptp_private *priv);
++extern void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
++				  struct sk_buff *skb,
++				  struct bufdesc *bdp);
++#else
++static inline int fec_ptp_init(struct fec_ptp_private *priv, int id)
++{
++	return 1;
++}
++static inline void fec_ptp_cleanup(struct fec_ptp_private *priv) { }
++static inline int fec_ptp_start(struct fec_ptp_private *priv)
++{
++	return 1;
++}
++static inline void fec_ptp_stop(struct fec_ptp_private *priv) {}
++static inline int fec_ptp_do_txstamp(struct sk_buff *skb)
++{
++	return 0;
++}
++static inline void fec_ptp_store_txstamp(struct fec_ptp_private *priv) {}
++static inline void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
++					 struct sk_buff *skb,
++					 struct bufdesc *bdp) {}
++#endif /* 1588 */
++
++#endif