target/linux/coldfire/patches/020-Add-dual-FEC-1588-timer-support.patch

   1 From 67d56859d24864af530506c76523f0fc3c5cb502 Mon Sep 17 00:00:00 2001
   2 From: Alison Wang <b18965@freescale.com>
   3 Date: Thu, 4 Aug 2011 09:59:44 +0800
   4 Subject: [PATCH 20/52] Add dual FEC 1588 timer support
   5
   6 Add Modelo dual FEC 1588 function with IXXXAT statck.
   7
   8 Signed-off-by: Alison Wang <b18965@freescale.com>
   9 ---
  10  drivers/net/Kconfig    |    6 +
  11  drivers/net/Makefile   |    3 +
  12  drivers/net/fec.c      |  153 ++++++++++++-
  13  drivers/net/fec.h      |   25 ++
  14  drivers/net/fec_1588.c |  626 ++++++++++++++++++++++++++++++++++++++++++++++++
  15  drivers/net/fec_1588.h |  195 +++++++++++++++
  16  6 files changed, 1006 insertions(+), 2 deletions(-)
  17  create mode 100644 drivers/net/fec_1588.c
  18  create mode 100644 drivers/net/fec_1588.h
  19
  20 --- a/drivers/net/Kconfig
  21 +++ b/drivers/net/Kconfig
  22 @@ -1958,6 +1958,12 @@ config FEC2
  23           Say Y here if you want to use the second built-in 10/100 Fast
  24           ethernet controller on some Motorola ColdFire processors.
  25
  26 +config FEC_1588
  27 +        bool "Enable 1588 interface(on some ColdFire designs)"
  28 +       depends on M5441X && FEC
  29 +       help
  30 +               Say Y here if 1588 function is enabled.
  31 +
  32  config FEC_548x
  33         tristate "MCF547x/MCF548x Fast Ethernet Controller support"
  34         depends on M547X_8X
  35 --- a/drivers/net/Makefile
  36 +++ b/drivers/net/Makefile
  37 @@ -123,6 +123,9 @@ obj-$(CONFIG_PCMCIA_PCNET) += 8390.o
  38  obj-$(CONFIG_HP100) += hp100.o
  39  obj-$(CONFIG_SMC9194) += smc9194.o
  40  obj-$(CONFIG_FEC) += fec.o
  41 +ifeq ($(CONFIG_FEC_1588), y)
  42 +obj-$(CONFIG_FEC) += fec_1588.o
  43 +endif
  44  obj-$(CONFIG_FEC_548x) += fec_m547x.o
  45  obj-$(CONFIG_FEC_MPC52xx) += fec_mpc52xx.o
  46  ifeq ($(CONFIG_FEC_MPC52xx_MDIO),y)
  47 --- a/drivers/net/fec.c
  48 +++ b/drivers/net/fec.c
  49 @@ -53,6 +53,7 @@
  50  #endif
  51
  52  #include "fec.h"
  53 +#include "fec_1588.h"
  54
  55  #if defined(CONFIG_ARCH_MXC) || defined(CONFIG_SOC_IMX28)
  56  #define FEC_ALIGNMENT  0xf
  57 @@ -135,8 +136,15 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet
  58  #define FEC_ENET_RXB   ((uint)0x01000000)      /* A buffer was received */
  59  #define FEC_ENET_MII   ((uint)0x00800000)      /* MII interrupt */
  60  #define FEC_ENET_EBERR ((uint)0x00400000)      /* SDMA bus error */
  61 +#define FEC_ENET_TS_AVAIL      ((uint)0x00010000)
  62 +#define FEC_ENET_TS_TIMER      ((uint)0x00008000)
  63
  64 +#if defined(CONFIG_FEC_1588)
  65 +#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII | \
  66 +                       FEC_ENET_TS_AVAIL | FEC_ENET_TS_TIMER)
  67 +#else
  68  #define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
  69 +#endif
  70
  71  /* The FEC stores dest/src/type, data, and checksum for receive packets.
  72   */
  73 @@ -209,6 +217,10 @@ struct fec_enet_private {
  74         int     link;
  75         int     full_duplex;
  76         struct  completion mdio_done;
  77 +#ifdef CONFIG_FEC_1588
  78 +       struct fec_ptp_private *ptp_priv;
  79 +       uint    ptimer_present;
  80 +#endif
  81  };
  82
  83  static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
  84 @@ -252,6 +264,9 @@ fec_enet_start_xmit(struct sk_buff *skb,
  85         struct bufdesc *bdp;
  86         void *bufaddr;
  87         unsigned short  status;
  88 +#ifdef CONFIG_FEC_1588
  89 +       unsigned long estatus;
  90 +#endif
  91         unsigned long flags;
  92
  93         if (!fep->link) {
  94 @@ -293,6 +308,17 @@ fec_enet_start_xmit(struct sk_buff *skb,
  95                 bufaddr = fep->tx_bounce[index];
  96         }
  97
  98 +#ifdef CONFIG_FEC_1588
  99 +       if (fep->ptimer_present) {
 100 +               if (fec_ptp_do_txstamp(skb))
 101 +                       estatus = BD_ENET_TX_TS;
 102 +               else
 103 +                       estatus = 0;
 104 +
 105 +               bdp->cbd_esc = (estatus | BD_ENET_TX_INT);
 106 +               bdp->cbd_bdu = 0;
 107 +       }
 108 +#endif
 109         /*
 110          * Some design made an incorrect assumption on endian mode of
 111          * the system that it's running on. As the result, driver has to
 112 @@ -357,6 +383,9 @@ fec_enet_interrupt(int irq, void * dev_i
 113  {
 114         struct  net_device *dev = dev_id;
 115         struct fec_enet_private *fep = netdev_priv(dev);
 116 +#ifdef CONFIG_FEC_1588
 117 +       struct fec_ptp_private *fpp = fep->ptp_priv;
 118 +#endif
 119         uint    int_events;
 120         irqreturn_t ret = IRQ_NONE;
 121
 122 @@ -364,6 +393,10 @@ fec_enet_interrupt(int irq, void * dev_i
 123                 int_events = readl(fep->hwp + FEC_IEVENT);
 124                 writel(int_events, fep->hwp + FEC_IEVENT);
 125
 126 +#ifdef CONFIG_FEC_1588
 127 +               if (__raw_readb(MCF_DTIM1_DTER) & MCF_DTIM_DTER_REF)
 128 +                       __raw_writeb(MCF_DTIM_DTER_REF, MCF_DTIM1_DTER);
 129 +#endif
 130                 if (int_events & FEC_ENET_RXF) {
 131                         ret = IRQ_HANDLED;
 132                         fec_enet_rx(dev);
 133 @@ -378,6 +411,19 @@ fec_enet_interrupt(int irq, void * dev_i
 134                         fec_enet_tx(dev);
 135                 }
 136
 137 +#ifdef CONFIG_FEC_1588
 138 +               if (int_events & FEC_ENET_TS_AVAIL) {
 139 +                       ret = IRQ_HANDLED;
 140 +                       fec_ptp_store_txstamp(fep->ptp_priv);
 141 +               }
 142 +
 143 +               if (int_events & FEC_ENET_TS_TIMER) {
 144 +                       ret = IRQ_HANDLED;
 145 +                       if (fep->ptimer_present)
 146 +                               fpp->prtc++;
 147 +               }
 148 +#endif
 149 +
 150                 if (int_events & FEC_ENET_MII) {
 151                         ret = IRQ_HANDLED;
 152                         complete(&fep->mdio_done);
 153 @@ -394,6 +440,9 @@ fec_enet_tx(struct net_device *dev)
 154         struct  fec_enet_private *fep;
 155         struct bufdesc *bdp;
 156         unsigned short status;
 157 +#ifdef CONFIG_FEC_1588
 158 +       unsigned long estatus;
 159 +#endif
 160         struct  sk_buff *skb;
 161
 162         fep = netdev_priv(dev);
 163 @@ -437,6 +486,13 @@ fec_enet_tx(struct net_device *dev)
 164                 if (status & BD_ENET_TX_DEF)
 165                         dev->stats.collisions++;
 166
 167 +#if defined(CONFIG_FEC_1588)
 168 +               if (fep->ptimer_present) {
 169 +                       estatus = bdp->cbd_esc;
 170 +                       if (estatus & BD_ENET_TX_TS)
 171 +                               fec_ptp_store_txstamp(fep->ptp_priv);
 172 +               }
 173 +#endif
 174                 /* Free the sk buffer associated with this last transmit */
 175                 dev_kfree_skb_any(skb);
 176                 fep->tx_skbuff[fep->skb_dirty] = NULL;
 177 @@ -470,6 +526,9 @@ static void
 178  fec_enet_rx(struct net_device *dev)
 179  {
 180         struct  fec_enet_private *fep = netdev_priv(dev);
 181 +#ifdef CONFIG_FEC_1588
 182 +       struct fec_ptp_private *fpp = fep->ptp_priv;
 183 +#endif
 184         const struct platform_device_id *id_entry =
 185                                 platform_get_device_id(fep->pdev);
 186         struct bufdesc *bdp;
 187 @@ -554,6 +613,12 @@ fec_enet_rx(struct net_device *dev)
 188                         skb_put(skb, pkt_len - 4);      /* Make room */
 189                         skb_copy_to_linear_data(skb, data, pkt_len - 4);
 190                         skb->protocol = eth_type_trans(skb, dev);
 191 +
 192 +#ifdef CONFIG_FEC_1588
 193 +                       /* 1588 messeage TS handle */
 194 +                       if (fep->ptimer_present)
 195 +                               fec_ptp_store_rxstamp(fpp, skb, bdp);
 196 +#endif
 197                         netif_rx(skb);
 198                 }
 199
 200 @@ -567,6 +632,11 @@ rx_processing_done:
 201                 status |= BD_ENET_RX_EMPTY;
 202                 bdp->cbd_sc = status;
 203
 204 +#ifdef CONFIG_FEC_1588
 205 +               bdp->cbd_esc = BD_ENET_RX_INT;
 206 +               bdp->cbd_prot = 0;
 207 +               bdp->cbd_bdu = 0;
 208 +#endif
 209                 /* Update BD pointer to next entry */
 210                 if (status & BD_ENET_RX_WRAP)
 211                         bdp = fep->rx_bd_base;
 212 @@ -669,8 +739,11 @@ static void fec_enet_adjust_link(struct
 213                         fec_stop(dev);
 214
 215                 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
 216 -                       writel(2, fep->hwp + FEC_ECNTRL);
 217 -
 218 +#ifdef CONFIG_FEC_1588
 219 +                       writel(0x00000012, fep->hwp + FEC_ECNTRL);
 220 +#else
 221 +                       writel(0x00000002, fep->hwp + FEC_ECNTRL);
 222 +#endif
 223                 status_change = 1;
 224         }
 225
 226 @@ -983,6 +1056,10 @@ static int fec_enet_alloc_buffers(struct
 227                 bdp->cbd_bufaddr = dma_map_single(&dev->dev, skb->data,
 228                                 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
 229                 bdp->cbd_sc = BD_ENET_RX_EMPTY;
 230 +
 231 +#ifdef CONFIG_FEC_1588
 232 +               bdp->cbd_esc = BD_ENET_RX_INT;
 233 +#endif
 234                 bdp++;
 235         }
 236
 237 @@ -996,6 +1073,9 @@ static int fec_enet_alloc_buffers(struct
 238
 239                 bdp->cbd_sc = 0;
 240                 bdp->cbd_bufaddr = 0;
 241 +#ifdef CONFIG_FEC_1588
 242 +               bdp->cbd_esc = BD_ENET_TX_INT;
 243 +#endif
 244                 bdp++;
 245         }
 246
 247 @@ -1256,8 +1336,12 @@ fec_restart(struct net_device *dev, int
 248                 writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
 249         }
 250
 251 +#ifdef CONFIG_FEC_1588
 252 +       writel(0x7fff8000, fep->hwp + FEC_IEVENT);
 253 +#else
 254         /* Clear any outstanding interrupt. */
 255         writel(0xffc00000, fep->hwp + FEC_IEVENT);
 256 +#endif
 257
 258         /* Reset all multicast. */
 259         writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
 260 @@ -1342,8 +1426,25 @@ fec_restart(struct net_device *dev, int
 261  #endif
 262         }
 263
 264 +#ifdef CONFIG_FEC_1588
 265 +       if (fep->ptimer_present) {
 266 +               int ret;
 267 +               /* Set Timer count */
 268 +               ret = fec_ptp_start(fep->ptp_priv);
 269 +               if (ret) {
 270 +                       fep->ptimer_present = 0;
 271 +                       writel(2, fep->hwp + FEC_ECNTRL);
 272 +               } else {
 273 +                       val = readl(fep->hwp + FEC_ECNTRL);
 274 +                       val |= 0x00000012;
 275 +                       writel(val, fep->hwp + FEC_ECNTRL);
 276 +               }
 277 +       } else
 278 +               writel(2, fep->hwp + FEC_ECNTRL);
 279 +#else
 280         /* And last, enable the transmit and receive processing */
 281         writel(2, fep->hwp + FEC_ECNTRL);
 282 +#endif
 283         writel(0, fep->hwp + FEC_R_DES_ACTIVE);
 284
 285         /* Enable interrupts we wish to service */
 286 @@ -1367,6 +1468,10 @@ fec_stop(struct net_device *dev)
 287         writel(1, fep->hwp + FEC_ECNTRL);
 288         udelay(10);
 289         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 290 +#ifdef CONFIG_FEC_1588
 291 +       if (fep->ptimer_present)
 292 +               fec_ptp_stop(fep->ptp_priv);
 293 +#endif
 294         writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
 295  }
 296
 297 @@ -1428,6 +1533,24 @@ fec_probe(struct platform_device *pdev)
 298                 }
 299         }
 300
 301 +#ifdef CONFIG_FEC_1588
 302 +       i = (pdev->id) ? (64 + 64 + 64 + 7) : (64 + 64 + 64);
 303 +       if (request_irq(i + 48, fec_enet_interrupt, IRQF_DISABLED,
 304 +                               "1588 TS AVAIL", ndev) != 0)
 305 +               printk(KERN_ERR "FEC: Could not alloc FEC %x 1588 TS AVAIL "
 306 +                       "IRQ(%d)!\n", pdev->id, i + 48);
 307 +
 308 +       if (pdev->id == 0) {
 309 +               printk("setup TS timer interrupt through DMA timer1\n");
 310 +               __raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
 311 +
 312 +               if (request_irq(64 + 33, fec_enet_interrupt, IRQF_DISABLED,
 313 +                                       "1588 TS TIMER", ndev) != 0)
 314 +                       printk(KERN_ERR "FEC: Could not alloc FEC %x 1588 TS"
 315 +                               " TIMER IRQ(%d)!\n", pdev->id, 64 + 33);
 316 +       }
 317 +#endif
 318 +
 319         fep->clk = clk_get(&pdev->dev, "fec_clk");
 320         if (IS_ERR(fep->clk)) {
 321                 ret = PTR_ERR(fep->clk);
 322 @@ -1443,6 +1566,20 @@ fec_probe(struct platform_device *pdev)
 323         if (ret)
 324                 goto failed_mii_init;
 325
 326 +#ifdef CONFIG_FEC_1588
 327 +       fep->ptp_priv = kzalloc(sizeof(struct fec_ptp_private),
 328 +                                       GFP_KERNEL);
 329 +       if (fep->ptp_priv) {
 330 +               fep->ptp_priv->hwp = fep->hwp;
 331 +               ret = fec_ptp_init(fep->ptp_priv, pdev->id);
 332 +               if (ret)
 333 +                       printk(KERN_ERR "IEEE1588: ptp-timer init failed\n");
 334 +               else
 335 +                       fep->ptimer_present = 1;
 336 +       } else
 337 +               printk(KERN_ERR "IEEE1588: failed to malloc memory\n");
 338 +#endif
 339 +
 340         /* Carrier starts down, phylib will bring it up */
 341         netif_carrier_off(ndev);
 342
 343 @@ -1454,6 +1591,12 @@ fec_probe(struct platform_device *pdev)
 344
 345  failed_register:
 346         fec_enet_mii_remove(fep);
 347 +#ifdef CONFIG_FEC_1588
 348 +       if (fep->ptimer_present)
 349 +               fec_ptp_cleanup(fep->ptp_priv);
 350 +
 351 +       kfree(fep->ptp_priv);
 352 +#endif
 353  failed_mii_init:
 354  failed_init:
 355         clk_disable(fep->clk);
 356 @@ -1485,6 +1628,12 @@ fec_drv_remove(struct platform_device *p
 357         clk_disable(fep->clk);
 358         clk_put(fep->clk);
 359         iounmap((void __iomem *)ndev->base_addr);
 360 +#ifdef CONFIG_FEC_1588
 361 +       if (fep->ptimer_present)
 362 +               fec_ptp_cleanup(fep->ptp_priv);
 363 +
 364 +       kfree(fep->ptp_priv);
 365 +#endif
 366         unregister_netdev(ndev);
 367         free_netdev(ndev);
 368         return 0;
 369 --- a/drivers/net/fec.h
 370 +++ b/drivers/net/fec.h
 371 @@ -50,6 +50,16 @@
 372  #define FEC_MIIGSK_CFGR                0x300 /* MIIGSK Configuration reg */
 373  #define FEC_MIIGSK_ENR         0x308 /* MIIGSK Enable reg */
 374
 375 +#if defined(CONFIG_FEC_1588)
 376 +#define FEC_ATIME_CTRL          0x400
 377 +#define FEC_ATIME               0x404
 378 +#define FEC_ATIME_EVT_OFFSET    0x408
 379 +#define FEC_ATIME_EVT_PERIOD    0x40c
 380 +#define FEC_ATIME_CORR          0x410
 381 +#define FEC_ATIME_INC           0x414
 382 +#define FEC_TS_TIMESTAMP        0x418
 383 +#endif
 384 +
 385  #else
 386
 387  #define FEC_ECNTRL             0x000 /* Ethernet control reg */
 388 @@ -78,6 +88,9 @@
 389
 390  #endif /* CONFIG_M5272 */
 391
 392 +#if defined(CONFIG_FEC_1588)
 393 +#define FEC_ENHANCED_MODE      1
 394 +#endif
 395
 396  /*
 397   *     Define the buffer descriptor structure.
 398 @@ -93,6 +106,14 @@ struct bufdesc {
 399         unsigned short  cbd_sc;                 /* Control and status info */
 400         unsigned short  cbd_datlen;             /* Data length */
 401         unsigned long   cbd_bufaddr;            /* Buffer address */
 402 +
 403 +#ifdef FEC_ENHANCED_MODE
 404 +       unsigned long cbd_esc;
 405 +       unsigned long cbd_prot;
 406 +       unsigned long cbd_bdu;
 407 +       unsigned long ts;
 408 +       unsigned short res0[4];
 409 +#endif
 410  };
 411  #endif
 412
 413 @@ -128,6 +149,7 @@ struct bufdesc {
 414  #define BD_ENET_RX_OV           ((ushort)0x0002)
 415  #define BD_ENET_RX_CL           ((ushort)0x0001)
 416  #define BD_ENET_RX_STATS        ((ushort)0x013f)        /* All status bits */
 417 +#define BD_ENET_RX_INT          0x00800000
 418
 419  /* Buffer descriptor control/status used by Ethernet transmit.
 420  */
 421 @@ -146,6 +168,9 @@ struct bufdesc {
 422  #define BD_ENET_TX_CSL          ((ushort)0x0001)
 423  #define BD_ENET_TX_STATS        ((ushort)0x03ff)        /* All status bits */
 424
 425 +#define BD_ENET_TX_TS           0x20000000
 426 +#define BD_ENET_TX_INT          0x40000000
 427 +#define BD_ENET_TX_BDU          0x80000000
 428
 429  /****************************************************************************/
 430  #endif /* FEC_H */
 431 --- /dev/null
 432 +++ b/drivers/net/fec_1588.c
 433 @@ -0,0 +1,626 @@
 434 +/*
 435 + * drivers/net/fec_1588.c
 436 + *
 437 + * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
 438 + * Copyright (C) 2009 IXXAT Automation, GmbH
 439 + *
 440 + * FEC Ethernet Driver -- IEEE 1588 interface functionality
 441 + *
 442 + * This program is free software; you can redistribute it and/or modify
 443 + * it under the terms of the GNU General Public License as published by
 444 + * the Free Software Foundation; either version 2 of the License, or
 445 + * (at your option) any later version.
 446 + *
 447 + * This program is distributed in the hope that it will be useful,
 448 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 449 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 450 + * GNU General Public License for more details.
 451 + *
 452 + * You should have received a copy of the GNU General Public License along
 453 + * with this program; if not, write to the Free Software Foundation, Inc.,
 454 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 455 + *
 456 + */
 457 +
 458 +#include <linux/io.h>
 459 +#include <linux/device.h>
 460 +#include <linux/fs.h>
 461 +#include <linux/vmalloc.h>
 462 +#include <linux/spinlock.h>
 463 +#include <linux/ip.h>
 464 +#include <linux/udp.h>
 465 +#include <asm/mcf5441x_ccm.h>
 466 +#include <asm/mcf5441x_dtim.h>
 467 +#include <asm/mcfsim.h>
 468 +#include "fec_1588.h"
 469 +
 470 +static DECLARE_WAIT_QUEUE_HEAD(ptp_rx_ts_wait);
 471 +#define PTP_GET_RX_TIMEOUT      (HZ/10)
 472 +#define COLDFIRE_DTIM1_INT     (64+32+1)
 473 +
 474 +static struct fec_ptp_private *ptp_private[2];
 475 +
 476 +static void init_DTIM1_for_1588(struct fec_ptp_private *priv)
 477 +{
 478 +       printk(KERN_INFO "Initializing DTIM1 for 1588 TS timer\n");
 479 +
 480 +       __raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
 481 +
 482 +       /*Enable 1588*/
 483 +
 484 +       __raw_writeb(MCF_DTIM_DTXMR_1588EN, MCF_DTIM1_DTXMR);
 485 +
 486 +       /*Compare to the 1588 timerbase*/
 487 +       __raw_writel(FEC_T_PERIOD_ONE_SEC - FEC_T_INC_40MHZ, MCF_DTIM1_DTRR);
 488 +
 489 +       __raw_writeb(MCF_DTIM_DTER_REF, MCF_DTIM1_DTER);
 490 +
 491 +       MCF_GPIO_PAR_TIMER = (MCF_GPIO_PAR_TIMER & MCF_GPIO_PAR_TIMER_T1IN_MASK)
 492 +                               | MCF_GPIO_PAR_TIMER_T1IN_T1OUT;
 493 +}
 494 +
 495 +static void start_DTIM1(void)
 496 +{
 497 +       __raw_writew(MCF_DTIM_DTMR_RST_EN | MCF_DTIM_DTMR_ORRI |
 498 +                       MCF_DTIM_DTMR_OM, MCF_DTIM1_DTMR);
 499 +}
 500 +
 501 +static void stop_DTIM1(void)
 502 +{
 503 +       __raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM1_DTMR);
 504 +}
 505 +
 506 +/* Alloc the ring resource */
 507 +static int fec_ptp_init_circ(struct circ_buf *ptp_buf)
 508 +{
 509 +       ptp_buf->buf = vmalloc(DEFAULT_PTP_RX_BUF_SZ *
 510 +                                       sizeof(struct fec_ptp_data_t));
 511 +
 512 +       if (!ptp_buf->buf)
 513 +               return 1;
 514 +       ptp_buf->head = 0;
 515 +       ptp_buf->tail = 0;
 516 +
 517 +       return 0;
 518 +}
 519 +
 520 +static inline int fec_ptp_calc_index(int size, int curr_index, int offset)
 521 +{
 522 +       return (curr_index + offset) % size;
 523 +}
 524 +
 525 +static int fec_ptp_is_empty(struct circ_buf *buf)
 526 +{
 527 +       return (buf->head == buf->tail);
 528 +}
 529 +
 530 +static int fec_ptp_nelems(struct circ_buf *buf)
 531 +{
 532 +       const int front = buf->head;
 533 +       const int end = buf->tail;
 534 +       const int size = DEFAULT_PTP_RX_BUF_SZ;
 535 +       int n_items;
 536 +
 537 +       if (end > front)
 538 +               n_items = end - front;
 539 +       else if (end < front)
 540 +               n_items = size - (front - end);
 541 +       else
 542 +               n_items = 0;
 543 +
 544 +       return n_items;
 545 +}
 546 +
 547 +static int fec_ptp_is_full(struct circ_buf *buf)
 548 +{
 549 +       if (fec_ptp_nelems(buf) ==
 550 +                               (DEFAULT_PTP_RX_BUF_SZ - 1))
 551 +               return 1;
 552 +       else
 553 +               return 0;
 554 +}
 555 +
 556 +static int fec_ptp_insert(struct circ_buf *ptp_buf,
 557 +                         struct fec_ptp_data_t *data,
 558 +                         struct fec_ptp_private *priv)
 559 +{
 560 +       struct fec_ptp_data_t *tmp;
 561 +
 562 +       if (fec_ptp_is_full(ptp_buf))
 563 +               return 1;
 564 +
 565 +       spin_lock(&priv->ptp_lock);
 566 +       tmp = (struct fec_ptp_data_t *)(ptp_buf->buf) + ptp_buf->tail;
 567 +
 568 +       tmp->key = data->key;
 569 +       tmp->ts_time.sec = data->ts_time.sec;
 570 +       tmp->ts_time.nsec = data->ts_time.nsec;
 571 +
 572 +       ptp_buf->tail = fec_ptp_calc_index(DEFAULT_PTP_RX_BUF_SZ,
 573 +                                       ptp_buf->tail, 1);
 574 +       spin_unlock(&priv->ptp_lock);
 575 +
 576 +       return 0;
 577 +}
 578 +
 579 +static int fec_ptp_find_and_remove(struct circ_buf *ptp_buf,
 580 +                                  int key,
 581 +                                  struct fec_ptp_data_t *data,
 582 +                                  struct fec_ptp_private *priv)
 583 +{
 584 +       int i;
 585 +       int size = DEFAULT_PTP_RX_BUF_SZ;
 586 +       int end = ptp_buf->tail;
 587 +       unsigned long flags;
 588 +       struct fec_ptp_data_t *tmp;
 589 +
 590 +       if (fec_ptp_is_empty(ptp_buf))
 591 +               return 1;
 592 +
 593 +       i = ptp_buf->head;
 594 +       while (i != end) {
 595 +               tmp = (struct fec_ptp_data_t *)(ptp_buf->buf) + i;
 596 +               if (tmp->key == key)
 597 +                       break;
 598 +               i = fec_ptp_calc_index(size, i, 1);
 599 +       }
 600 +
 601 +       spin_lock_irqsave(&priv->ptp_lock, flags);
 602 +       if (i == end) {
 603 +               ptp_buf->head = end;
 604 +               spin_unlock_irqrestore(&priv->ptp_lock, flags);
 605 +               return 1;
 606 +       }
 607 +
 608 +       data->ts_time.sec = tmp->ts_time.sec;
 609 +       data->ts_time.nsec = tmp->ts_time.nsec;
 610 +
 611 +       ptp_buf->head = fec_ptp_calc_index(size, i, 1);
 612 +       spin_unlock_irqrestore(&priv->ptp_lock, flags);
 613 +
 614 +       return 0;
 615 +}
 616 +
 617 +/* 1588 Module intialization */
 618 +int fec_ptp_start(struct fec_ptp_private *priv)
 619 +{
 620 +       struct fec_ptp_private *fpp = priv;
 621 +
 622 +       MCF_CCM_MISCCR3 = 0x0000;
 623 +
 624 +       init_DTIM1_for_1588(priv);
 625 +
 626 +       /* Select 1588 Timer source and enable module for starting Tmr Clock */
 627 +       fec_writel(FEC_T_CTRL_RESTART, fpp->hwp + FEC_ATIME_CTRL);
 628 +       fec_writel(FEC_T_INC_40MHZ << FEC_T_INC_OFFSET,
 629 +                       fpp->hwp + FEC_ATIME_INC);
 630 +       fec_writel(FEC_T_PERIOD_ONE_SEC, fpp->hwp + FEC_ATIME_EVT_PERIOD);
 631 +       /* start counter */
 632 +       fec_writel(FEC_T_CTRL_PERIOD_RST | FEC_T_CTRL_ENABLE |
 633 +               FEC_T_CTRL_PINPER, fpp->hwp + FEC_ATIME_CTRL);
 634 +
 635 +       start_DTIM1();
 636 +
 637 +       return 0;
 638 +}
 639 +
 640 +/* Cleanup routine for 1588 module.
 641 + * When PTP is disabled this routing is called */
 642 +void fec_ptp_stop(struct fec_ptp_private *priv)
 643 +{
 644 +       struct fec_ptp_private *fpp = priv;
 645 +
 646 +       fec_writel(0, fpp->hwp + FEC_ATIME_CTRL);
 647 +       fec_writel(FEC_T_CTRL_RESTART, fpp->hwp + FEC_ATIME_CTRL);
 648 +       stop_DTIM1();
 649 +}
 650 +
 651 +static void fec_get_curr_cnt(struct fec_ptp_private *priv,
 652 +                       struct ptp_rtc_time *curr_time)
 653 +{
 654 +       u32 tempval;
 655 +
 656 +       fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
 657 +       fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
 658 +       curr_time->rtc_time.nsec = fec_readl(priv->hwp + FEC_ATIME);
 659 +       curr_time->rtc_time.sec = priv->prtc;
 660 +
 661 +       fec_writel(FEC_T_CTRL_CAPTURE, priv->hwp + FEC_ATIME_CTRL);
 662 +       tempval = fec_readl(priv->hwp + FEC_ATIME);
 663 +       if (tempval < curr_time->rtc_time.nsec) {
 664 +               curr_time->rtc_time.nsec = tempval;
 665 +               curr_time->rtc_time.sec = priv->prtc;
 666 +       }
 667 +}
 668 +
 669 +/* Set the 1588 timer counter registers */
 670 +static void fec_set_1588cnt(struct fec_ptp_private *priv,
 671 +                       struct ptp_rtc_time *fec_time)
 672 +{
 673 +       u32 tempval;
 674 +       unsigned long flags;
 675 +
 676 +       spin_lock_irqsave(&priv->cnt_lock, flags);
 677 +
 678 +       priv->prtc = fec_time->rtc_time.sec;
 679 +
 680 +       tempval = fec_time->rtc_time.nsec;
 681 +       fec_writel(tempval, priv->hwp + FEC_ATIME);
 682 +       spin_unlock_irqrestore(&priv->cnt_lock, flags);
 683 +}
 684 +
 685 +/* Set the BD to ptp */
 686 +int fec_ptp_do_txstamp(struct sk_buff *skb)
 687 +{
 688 +       struct iphdr *iph;
 689 +       struct udphdr *udph;
 690 +
 691 +       if (skb->len > 44) {
 692 +               /* Check if port is 319 for PTP Event, and check for UDP */
 693 +               iph = ip_hdr(skb);
 694 +               if (iph == NULL || iph->protocol != FEC_PACKET_TYPE_UDP)
 695 +                       return 0;
 696 +
 697 +               udph = udp_hdr(skb);
 698 +               if (udph != NULL && ntohs(udph->source) == 319)
 699 +                       return 1;
 700 +       }
 701 +
 702 +       return 0;
 703 +}
 704 +
 705 +void fec_ptp_store_txstamp(struct fec_ptp_private *priv)
 706 +{
 707 +       struct fec_ptp_private *fpp = priv;
 708 +       unsigned int reg;
 709 +
 710 +       reg = fec_readl(fpp->hwp + FEC_TS_TIMESTAMP);
 711 +       fpp->txstamp.nsec = reg;
 712 +       fpp->txstamp.sec = fpp->prtc;
 713 +}
 714 +
 715 +void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
 716 +                          struct sk_buff *skb,
 717 +                          struct bufdesc *bdp)
 718 +{
 719 +       int msg_type, seq_id, control;
 720 +       struct fec_ptp_data_t tmp_rx_time;
 721 +       struct fec_ptp_private *fpp = priv;
 722 +       struct iphdr *iph;
 723 +       struct udphdr *udph;
 724 +
 725 +       /* Check for UDP, and Check if port is 319 for PTP Event */
 726 +       iph = (struct iphdr *)(skb->data + FEC_PTP_IP_OFFS);
 727 +       if (iph->protocol != FEC_PACKET_TYPE_UDP)
 728 +               return;
 729 +
 730 +       udph = (struct udphdr *)(skb->data + FEC_PTP_UDP_OFFS);
 731 +       if (ntohs(udph->source) != 319)
 732 +               return;
 733 +
 734 +       seq_id = *((u16 *)(skb->data + FEC_PTP_SEQ_ID_OFFS));
 735 +       control = *((u8 *)(skb->data + FEC_PTP_CTRL_OFFS));
 736 +
 737 +       tmp_rx_time.key = ntohs(seq_id);
 738 +       tmp_rx_time.ts_time.sec = fpp->prtc;
 739 +       tmp_rx_time.ts_time.nsec = bdp->ts;
 740 +
 741 +       switch (control) {
 742 +
 743 +       case PTP_MSG_SYNC:
 744 +               fec_ptp_insert(&(priv->rx_time_sync), &tmp_rx_time, priv);
 745 +               break;
 746 +
 747 +       case PTP_MSG_DEL_REQ:
 748 +               fec_ptp_insert(&(priv->rx_time_del_req), &tmp_rx_time, priv);
 749 +               break;
 750 +
 751 +       /* clear transportSpecific field*/
 752 +       case PTP_MSG_ALL_OTHER:
 753 +               msg_type = (*((u8 *)(skb->data +
 754 +                               FEC_PTP_MSG_TYPE_OFFS))) & 0x0F;
 755 +               switch (msg_type) {
 756 +               case PTP_MSG_P_DEL_REQ:
 757 +                       fec_ptp_insert(&(priv->rx_time_pdel_req),
 758 +                                               &tmp_rx_time, priv);
 759 +                       break;
 760 +               case PTP_MSG_P_DEL_RESP:
 761 +                       fec_ptp_insert(&(priv->rx_time_pdel_resp),
 762 +                                       &tmp_rx_time, priv);
 763 +                       break;
 764 +               default:
 765 +                       break;
 766 +               }
 767 +               break;
 768 +       default:
 769 +               break;
 770 +       }
 771 +
 772 +       wake_up_interruptible(&ptp_rx_ts_wait);
 773 +}
 774 +
 775 +static void fec_get_tx_timestamp(struct fec_ptp_private *priv,
 776 +                                struct ptp_time *tx_time)
 777 +{
 778 +       tx_time->sec = priv->txstamp.sec;
 779 +       tx_time->nsec = priv->txstamp.nsec;
 780 +}
 781 +
 782 +static uint8_t fec_get_rx_time(struct fec_ptp_private *priv,
 783 +                              struct ptp_ts_data *pts,
 784 +                              struct ptp_time *rx_time)
 785 +{
 786 +       struct fec_ptp_data_t tmp;
 787 +       int key, flag;
 788 +       u8 mode;
 789 +
 790 +       key = pts->seq_id;
 791 +       mode = pts->message_type;
 792 +       switch (mode) {
 793 +       case PTP_MSG_SYNC:
 794 +               flag = fec_ptp_find_and_remove(&(priv->rx_time_sync),
 795 +                                               key, &tmp, priv);
 796 +               break;
 797 +       case PTP_MSG_DEL_REQ:
 798 +               flag = fec_ptp_find_and_remove(&(priv->rx_time_del_req),
 799 +                                               key, &tmp, priv);
 800 +               break;
 801 +
 802 +       case PTP_MSG_P_DEL_REQ:
 803 +               flag = fec_ptp_find_and_remove(&(priv->rx_time_pdel_req),
 804 +                                               key, &tmp, priv);
 805 +               break;
 806 +       case PTP_MSG_P_DEL_RESP:
 807 +               flag = fec_ptp_find_and_remove(&(priv->rx_time_pdel_resp),
 808 +                                               key, &tmp, priv);
 809 +               break;
 810 +
 811 +       default:
 812 +               flag = 1;
 813 +               printk(KERN_ERR "ERROR\n");
 814 +               break;
 815 +       }
 816 +
 817 +       if (!flag) {
 818 +               rx_time->sec = tmp.ts_time.sec;
 819 +               rx_time->nsec = tmp.ts_time.nsec;
 820 +               return 0;
 821 +       } else {
 822 +               wait_event_interruptible_timeout(ptp_rx_ts_wait, 0,
 823 +                                       PTP_GET_RX_TIMEOUT);
 824 +
 825 +               switch (mode) {
 826 +               case PTP_MSG_SYNC:
 827 +                       flag = fec_ptp_find_and_remove(&(priv->rx_time_sync),
 828 +                               key, &tmp, priv);
 829 +                       break;
 830 +               case PTP_MSG_DEL_REQ:
 831 +                       flag = fec_ptp_find_and_remove(
 832 +                               &(priv->rx_time_del_req), key, &tmp, priv);
 833 +                       break;
 834 +               case PTP_MSG_P_DEL_REQ:
 835 +                       flag = fec_ptp_find_and_remove(
 836 +                               &(priv->rx_time_pdel_req), key, &tmp, priv);
 837 +                       break;
 838 +               case PTP_MSG_P_DEL_RESP:
 839 +                       flag = fec_ptp_find_and_remove(
 840 +                               &(priv->rx_time_pdel_resp), key, &tmp, priv);
 841 +                       break;
 842 +               }
 843 +
 844 +               if (flag == 0) {
 845 +                       rx_time->sec = tmp.ts_time.sec;
 846 +                       rx_time->nsec = tmp.ts_time.nsec;
 847 +                       return 0;
 848 +               }
 849 +
 850 +               return -1;
 851 +       }
 852 +}
 853 +
 854 +static void fec_handle_ptpdrift(
 855 +       struct ptp_set_comp *comp,
 856 +       struct ptp_time_correct *ptc)
 857 +{
 858 +       u32 ndrift;
 859 +       u32 i;
 860 +       u32 tmp, tmp_ns, tmp_prid;
 861 +       u32 min_ns, min_prid, miss_ns;
 862 +
 863 +       ndrift = comp->drift;
 864 +       if (ndrift == 0) {
 865 +               ptc->corr_inc = 0;
 866 +               ptc->corr_period = 0;
 867 +               return;
 868 +       }
 869 +
 870 +       if (ndrift >= FEC_ATIME_40MHZ) {
 871 +               ptc->corr_inc = (u32)(ndrift / FEC_ATIME_40MHZ);
 872 +               ptc->corr_period = 1;
 873 +               return;
 874 +       }
 875 +
 876 +       min_ns = 1;
 877 +       tmp = FEC_ATIME_40MHZ % ndrift;
 878 +       tmp_prid = (u32)(FEC_ATIME_40MHZ / ndrift);
 879 +       min_prid = tmp_prid;
 880 +       miss_ns = tmp / tmp_prid;
 881 +       for (i = 2; i <= FEC_T_INC_40MHZ; i++) {
 882 +               tmp = (FEC_ATIME_40MHZ * i) % ndrift;
 883 +               tmp_prid = (FEC_ATIME_40MHZ * i) / ndrift;
 884 +               tmp_ns = tmp / tmp_prid;
 885 +               if (tmp_ns <= 10) {
 886 +                       min_ns = i;
 887 +                       min_prid = tmp_prid;
 888 +                       break;
 889 +               }
 890 +
 891 +               if (tmp_ns < miss_ns) {
 892 +                       min_ns = i;
 893 +                       min_prid = tmp_prid;
 894 +                       miss_ns = tmp_ns;
 895 +               }
 896 +       }
 897 +
 898 +       ptc->corr_inc = min_ns;
 899 +       ptc->corr_period = min_prid;
 900 +}
 901 +
 902 +static void fec_set_drift(struct fec_ptp_private *priv,
 903 +       struct ptp_set_comp *comp)
 904 +{
 905 +       struct ptp_time_correct tc;
 906 +       struct fec_ptp_private *fpp = priv;
 907 +       u32 tmp, corr_ns;
 908 +
 909 +       fec_handle_ptpdrift(comp, &tc);
 910 +       if (tc.corr_inc == 0)
 911 +               return;
 912 +
 913 +       if (comp->o_ops == TRUE)
 914 +               corr_ns = FEC_T_INC_40MHZ + tc.corr_inc;
 915 +       else
 916 +               corr_ns = FEC_T_INC_40MHZ - tc.corr_inc;
 917 +
 918 +       tmp = fec_readl(fpp->hwp + FEC_ATIME_INC) & FEC_T_INC_MASK;
 919 +       tmp |= corr_ns << FEC_T_INC_CORR_OFFSET;
 920 +       fec_writel(tmp, fpp->hwp + FEC_ATIME_INC);
 921 +
 922 +       fec_writel(tc.corr_period, fpp->hwp + FEC_ATIME_CORR);
 923 +}
 924 +
 925 +static int ptp_open(struct inode *inode, struct file *file)
 926 +{
 927 +       return 0;
 928 +}
 929 +
 930 +static int ptp_release(struct inode *inode, struct file *file)
 931 +{
 932 +       return 0;
 933 +}
 934 +
 935 +static long ptp_unlocked_ioctl(
 936 +       struct file *file,
 937 +       unsigned int cmd,
 938 +       unsigned long arg)
 939 +{
 940 +       struct ptp_rtc_time *cnt;
 941 +       struct ptp_rtc_time curr_time;
 942 +       struct ptp_time rx_time, tx_time;
 943 +       struct ptp_ts_data *p_ts;
 944 +       struct ptp_set_comp *p_comp;
 945 +       struct fec_ptp_private *priv;
 946 +       struct inode *inode = file->f_mapping->host;
 947 +       unsigned int minor = MINOR(inode->i_rdev);
 948 +       long retval = 0;
 949 +
 950 +       priv = (struct fec_ptp_private *) ptp_private[minor];
 951 +       switch (cmd) {
 952 +       case PTP_GET_RX_TIMESTAMP:
 953 +               p_ts = (struct ptp_ts_data *)arg;
 954 +               retval = fec_get_rx_time(priv, p_ts, &rx_time);
 955 +               if (retval == 0)
 956 +                       copy_to_user((void __user *)(&(p_ts->ts)), &rx_time,
 957 +                                       sizeof(rx_time));
 958 +               break;
 959 +       case PTP_GET_TX_TIMESTAMP:
 960 +               p_ts = (struct ptp_ts_data *)arg;
 961 +               fec_get_tx_timestamp(priv, &tx_time);
 962 +               copy_to_user((void __user *)(&(p_ts->ts)), &tx_time,
 963 +                               sizeof(tx_time));
 964 +               break;
 965 +       case PTP_GET_CURRENT_TIME:
 966 +               fec_get_curr_cnt(priv, &curr_time);
 967 +               copy_to_user((void __user *)arg, &curr_time, sizeof(curr_time));
 968 +               break;
 969 +       case PTP_SET_RTC_TIME:
 970 +               cnt = (struct ptp_rtc_time *)arg;
 971 +               fec_set_1588cnt(priv, cnt);
 972 +               break;
 973 +       case PTP_FLUSH_TIMESTAMP:
 974 +               /* reset sync buffer */
 975 +               priv->rx_time_sync.head = 0;
 976 +               priv->rx_time_sync.tail = 0;
 977 +               /* reset delay_req buffer */
 978 +               priv->rx_time_del_req.head = 0;
 979 +               priv->rx_time_del_req.tail = 0;
 980 +               /* reset pdelay_req buffer */
 981 +               priv->rx_time_pdel_req.head = 0;
 982 +               priv->rx_time_pdel_req.tail = 0;
 983 +               /* reset pdelay_resp buffer */
 984 +               priv->rx_time_pdel_resp.head = 0;
 985 +               priv->rx_time_pdel_resp.tail = 0;
 986 +               break;
 987 +       case PTP_SET_COMPENSATION:
 988 +               p_comp = (struct ptp_set_comp *)arg;
 989 +               fec_set_drift(priv, p_comp);
 990 +               break;
 991 +       case PTP_GET_ORIG_COMP:
 992 +               ((struct ptp_get_comp *)arg)->dw_origcomp = FEC_PTP_ORIG_COMP;
 993 +               break;
 994 +       default:
 995 +               return -EINVAL;
 996 +       }
 997 +       return retval;
 998 +}
 999 +
1000 +static const struct file_operations ptp_fops = {
1001 +       .owner  = THIS_MODULE,
1002 +       .llseek = NULL,
1003 +       .read   = NULL,
1004 +       .write  = NULL,
1005 +       .unlocked_ioctl = ptp_unlocked_ioctl,
1006 +       .open   = ptp_open,
1007 +       .release = ptp_release,
1008 +};
1009 +
1010 +static int init_ptp(void)
1011 +{
1012 +       if (register_chrdev(PTP_MAJOR, "ptp", &ptp_fops))
1013 +               printk(KERN_ERR "Unable to register PTP deivce as char\n");
1014 +
1015 +       return 0;
1016 +}
1017 +
1018 +static void ptp_free(void)
1019 +{
1020 +       /*unregister the PTP device*/
1021 +       unregister_chrdev(PTP_MAJOR, "ptp");
1022 +}
1023 +
1024 +
1025 +
1026 +/*
1027 + * Resource required for accessing 1588 Timer Registers.
1028 + */
1029 +int fec_ptp_init(struct fec_ptp_private *priv, int id)
1030 +{
1031 +       fec_ptp_init_circ(&(priv->rx_time_sync));
1032 +       fec_ptp_init_circ(&(priv->rx_time_del_req));
1033 +       fec_ptp_init_circ(&(priv->rx_time_pdel_req));
1034 +       fec_ptp_init_circ(&(priv->rx_time_pdel_resp));
1035 +
1036 +       spin_lock_init(&priv->ptp_lock);
1037 +       spin_lock_init(&priv->cnt_lock);
1038 +       ptp_private[id] = priv;
1039 +       if (id == 0)
1040 +               init_ptp();
1041 +       return 0;
1042 +}
1043 +EXPORT_SYMBOL(fec_ptp_init);
1044 +
1045 +void fec_ptp_cleanup(struct fec_ptp_private *priv)
1046 +{
1047 +
1048 +       if (priv->rx_time_sync.buf)
1049 +               vfree(priv->rx_time_sync.buf);
1050 +       if (priv->rx_time_del_req.buf)
1051 +               vfree(priv->rx_time_del_req.buf);
1052 +       if (priv->rx_time_pdel_req.buf)
1053 +               vfree(priv->rx_time_pdel_req.buf);
1054 +       if (priv->rx_time_pdel_resp.buf)
1055 +               vfree(priv->rx_time_pdel_resp.buf);
1056 +
1057 +       ptp_free();
1058 +}
1059 +EXPORT_SYMBOL(fec_ptp_cleanup);
1060 --- /dev/null
1061 +++ b/drivers/net/fec_1588.h
1062 @@ -0,0 +1,195 @@
1063 +/*
1064 + * drivers/net/fec_1588.h
1065 + *
1066 + * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
1067 + *
1068 + * This program is free software; you can redistribute it and/or modify
1069 + * it under the terms of the GNU General Public License as published by
1070 + * the Free Software Foundation; either version 2 of the License, or
1071 + * (at your option) any later version.
1072 + *
1073 + * This program is distributed in the hope that it will be useful,
1074 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1075 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1076 + * GNU General Public License for more details.
1077 + *
1078 + * You should have received a copy of the GNU General Public License along
1079 + * with this program; if not, write to the Free Software Foundation, Inc.,
1080 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
1081 + *
1082 + */
1083 +
1084 +#ifndef FEC_1588_H
1085 +#define FEC_1588_H
1086 +
1087 +#include <linux/circ_buf.h>
1088 +#include "fec.h"
1089 +
1090 +#define fec_readl(addr) \
1091 +       ({ unsigned int __v = (*(volatile unsigned int *) (addr)); __v; })
1092 +
1093 +#define fec_writel(b, addr) (void)((*(volatile unsigned int *) (addr)) = (b))
1094 +
1095 +#define FALSE                  0
1096 +#define TRUE                   1
1097 +
1098 +/* FEC 1588 register bits */
1099 +#define FEC_T_CTRL_CAPTURE             0x00000800
1100 +#define FEC_T_CTRL_RESTART             0x00000200
1101 +#define FEC_T_CTRL_PERIOD_RST          0x00000010
1102 +#define FEC_T_CTRL_PINPER              0x00000080
1103 +#define FEC_T_CTRL_ENABLE              0x00000001
1104 +
1105 +#define FEC_T_INC_MASK                 0x0000007f
1106 +#define FEC_T_INC_OFFSET               0
1107 +#define FEC_T_INC_CORR_MASK            0x00007f00
1108 +#define FEC_T_INC_CORR_OFFSET          8
1109 +
1110 +#define FEC_T_INC_40MHZ                        8
1111 +#define FEC_ATIME_40MHZ                        125000000
1112 +
1113 +#define FEC_T_PERIOD_ONE_SEC           0x3B9ACA00
1114 +
1115 +/* IEEE 1588 definition */
1116 +#define FEC_ECNTRL_TS_EN       0x10
1117 +#define PTP_MAJOR              232     /*the temporary major number
1118 +                                                *used by PTP driver, the major
1119 +                                                *number 232~239 is unassigned*/
1120 +
1121 +#define DEFAULT_PTP_RX_BUF_SZ          2048
1122 +#define PTP_MSG_SYNC                   0x0
1123 +#define PTP_MSG_DEL_REQ                        0x1
1124 +#define PTP_MSG_P_DEL_REQ              0x2
1125 +#define PTP_MSG_P_DEL_RESP             0x3
1126 +#define PTP_MSG_DEL_RESP               0x4
1127 +#define PTP_MSG_ALL_OTHER              0x5
1128 +
1129 +#define PTP_GET_TX_TIMESTAMP           0x1
1130 +#define PTP_GET_RX_TIMESTAMP           0x9
1131 +#define PTP_SET_RTC_TIME               0x3
1132 +#define PTP_SET_COMPENSATION           0x4
1133 +#define PTP_GET_CURRENT_TIME           0x5
1134 +#define PTP_FLUSH_TIMESTAMP            0x6
1135 +#define PTP_ADJ_ADDEND                 0x7
1136 +#define PTP_GET_ORIG_COMP              0x8
1137 +#define PTP_GET_ADDEND                 0xB
1138 +#define PTP_GET_RX_TIMESTAMP_PDELAY_REQ                0xC
1139 +#define PTP_GET_RX_TIMESTAMP_PDELAY_RESP       0xD
1140 +
1141 +#define FEC_PTP_DOMAIN_DLFT            0xe0000181
1142 +#define FEC_PTP_IP_OFFS                        0x0
1143 +#define FEC_PTP_UDP_OFFS               0x14
1144 +#define FEC_PTP_MSG_TYPE_OFFS          0x1C
1145 +#define FEC_PTP_SEQ_ID_OFFS            0x3A
1146 +#define FEC_PTP_COR_NS                 0x24
1147 +#define FEC_PTP_CTRL_OFFS              0x3C
1148 +#define FEC_PACKET_TYPE_UDP            0x11
1149 +
1150 +#define FEC_PTP_ORIG_COMP              0x15555
1151 +
1152 +/* PTP standard time representation structure */
1153 +struct ptp_time {
1154 +       u64 sec;        /* seconds */
1155 +       u32 nsec;       /* nanoseconds */
1156 +};
1157 +
1158 +/* Structure for PTP Time Stamp */
1159 +struct fec_ptp_data_t {
1160 +       int             key;
1161 +       struct ptp_time ts_time;
1162 +};
1163 +
1164 +/* interface for PTP driver command GET_TX_TIME */
1165 +struct ptp_ts_data {
1166 +       /* PTP version */
1167 +       u8 version;
1168 +       /* PTP source port ID */
1169 +       u8 spid[10];
1170 +       /* PTP sequence ID */
1171 +       u16 seq_id;
1172 +       /* PTP message type */
1173 +       u8 message_type;
1174 +       /* PTP timestamp */
1175 +       struct ptp_time ts;
1176 +};
1177 +
1178 +/* interface for PTP driver command SET_RTC_TIME/GET_CURRENT_TIME */
1179 +struct ptp_rtc_time {
1180 +       struct ptp_time rtc_time;
1181 +};
1182 +
1183 +/* interface for PTP driver command SET_COMPENSATION */
1184 +struct ptp_set_comp {
1185 +       u32 drift;
1186 +       u32 o_ops;
1187 +};
1188 +
1189 +/* interface for PTP driver command GET_ORIG_COMP */
1190 +struct ptp_get_comp {
1191 +       /* the initial compensation value */
1192 +       u32 dw_origcomp;
1193 +       /* the minimum compensation value */
1194 +       u32 dw_mincomp;
1195 +       /*the max compensation value*/
1196 +       u32 dw_maxcomp;
1197 +       /*the min drift applying min compensation value in ppm*/
1198 +       u32 dw_mindrift;
1199 +       /*the max drift applying max compensation value in ppm*/
1200 +       u32 dw_maxdrift;
1201 +};
1202 +
1203 +struct ptp_time_correct {
1204 +       u32 corr_period;
1205 +       u32 corr_inc;
1206 +};
1207 +
1208 +/* PTP message version */
1209 +#define PTP_1588_MSG_VER_1     1
1210 +#define PTP_1588_MSG_VER_2     2
1211 +
1212 +struct fec_ptp_private {
1213 +       void __iomem *hwp;
1214 +
1215 +       struct  circ_buf rx_time_sync;
1216 +       struct  circ_buf rx_time_del_req;
1217 +       struct  circ_buf rx_time_pdel_req;
1218 +       struct  circ_buf rx_time_pdel_resp;
1219 +       spinlock_t ptp_lock;
1220 +       spinlock_t cnt_lock;
1221 +
1222 +       u64     prtc;
1223 +       struct ptp_time txstamp;
1224 +};
1225 +
1226 +#ifdef CONFIG_FEC_1588
1227 +extern int fec_ptp_init(struct fec_ptp_private *priv, int id);
1228 +extern void fec_ptp_cleanup(struct fec_ptp_private *priv);
1229 +extern int fec_ptp_start(struct fec_ptp_private *priv);
1230 +extern void fec_ptp_stop(struct fec_ptp_private *priv);
1231 +extern int fec_ptp_do_txstamp(struct sk_buff *skb);
1232 +extern void fec_ptp_store_txstamp(struct fec_ptp_private *priv);
1233 +extern void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
1234 +                                 struct sk_buff *skb,
1235 +                                 struct bufdesc *bdp);
1236 +#else
1237 +static inline int fec_ptp_init(struct fec_ptp_private *priv, int id)
1238 +{
1239 +       return 1;
1240 +}
1241 +static inline void fec_ptp_cleanup(struct fec_ptp_private *priv) { }
1242 +static inline int fec_ptp_start(struct fec_ptp_private *priv)
1243 +{
1244 +       return 1;
1245 +}
1246 +static inline void fec_ptp_stop(struct fec_ptp_private *priv) {}
1247 +static inline int fec_ptp_do_txstamp(struct sk_buff *skb)
1248 +{
1249 +       return 0;
1250 +}
1251 +static inline void fec_ptp_store_txstamp(struct fec_ptp_private *priv) {}
1252 +static inline void fec_ptp_store_rxstamp(struct fec_ptp_private *priv,
1253 +                                        struct sk_buff *skb,
1254 +                                        struct bufdesc *bdp) {}
1255 +#endif /* 1588 */
1256 +
1257 +#endif