drivers/net/ethernet/renesas/ravb_ptp.c

   1 /* PTP 1588 clock using the Renesas Ethernet AVB
   2  *
   3  * Copyright (C) 2013-2015 Renesas Electronics Corporation
   4  * Copyright (C) 2015 Renesas Solutions Corp.
   5  * Copyright (C) 2015 Cogent Embedded, Inc. <source@cogentembedded.com>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  */
  12
  13 #include "ravb.h"
  14
  15 static int ravb_ptp_tcr_request(struct ravb_private *priv, u32 request)
  16 {
  17         struct net_device *ndev = priv->ndev;
  18         int error;
  19
  20         error = ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
  21         if (error)
  22                 return error;
  23
  24         ravb_write(ndev, ravb_read(ndev, GCCR) | request, GCCR);
  25         return ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
  26 }
  27
  28 /* Caller must hold the lock */
  29 static int ravb_ptp_time_read(struct ravb_private *priv, struct timespec64 *ts)
  30 {
  31         struct net_device *ndev = priv->ndev;
  32         int error;
  33
  34         error = ravb_ptp_tcr_request(priv, GCCR_TCR_CAPTURE);
  35         if (error)
  36                 return error;
  37
  38         ts->tv_nsec = ravb_read(ndev, GCT0);
  39         ts->tv_sec  = ravb_read(ndev, GCT1) |
  40                 ((s64)ravb_read(ndev, GCT2) << 32);
  41
  42         return 0;
  43 }
  44
  45 /* Caller must hold the lock */
  46 static int ravb_ptp_time_write(struct ravb_private *priv,
  47                                 const struct timespec64 *ts)
  48 {
  49         struct net_device *ndev = priv->ndev;
  50         int error;
  51         u32 gccr;
  52
  53         error = ravb_ptp_tcr_request(priv, GCCR_TCR_RESET);
  54         if (error)
  55                 return error;
  56
  57         gccr = ravb_read(ndev, GCCR);
  58         if (gccr & GCCR_LTO)
  59                 return -EBUSY;
  60         ravb_write(ndev, ts->tv_nsec, GTO0);
  61         ravb_write(ndev, ts->tv_sec,  GTO1);
  62         ravb_write(ndev, (ts->tv_sec >> 32) & 0xffff, GTO2);
  63         ravb_write(ndev, gccr | GCCR_LTO, GCCR);
  64
  65         return 0;
  66 }
  67
  68 /* Caller must hold the lock */
  69 static int ravb_ptp_update_compare(struct ravb_private *priv, u32 ns)
  70 {
  71         struct net_device *ndev = priv->ndev;
  72         /* When the comparison value (GPTC.PTCV) is in range of
  73          * [x-1 to x+1] (x is the configured increment value in
  74          * GTI.TIV), it may happen that a comparison match is
  75          * not detected when the timer wraps around.
  76          */
  77         u32 gti_ns_plus_1 = (priv->ptp.current_addend >> 20) + 1;
  78         u32 gccr;
  79
  80         if (ns < gti_ns_plus_1)
  81                 ns = gti_ns_plus_1;
  82         else if (ns > 0 - gti_ns_plus_1)
  83                 ns = 0 - gti_ns_plus_1;
  84
  85         gccr = ravb_read(ndev, GCCR);
  86         if (gccr & GCCR_LPTC)
  87                 return -EBUSY;
  88         ravb_write(ndev, ns, GPTC);
  89         ravb_write(ndev, gccr | GCCR_LPTC, GCCR);
  90
  91         return 0;
  92 }
  93
  94 /* PTP clock operations */
  95 static int ravb_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
  96 {
  97         struct ravb_private *priv = container_of(ptp, struct ravb_private,
  98                                                  ptp.info);
  99         struct net_device *ndev = priv->ndev;
 100         unsigned long flags;
 101         u32 diff, addend;
 102         bool neg_adj = false;
 103         u32 gccr;
 104
 105         if (ppb < 0) {
 106                 neg_adj = true;
 107                 ppb = -ppb;
 108         }
 109         addend = priv->ptp.default_addend;
 110         diff = div_u64((u64)addend * ppb, NSEC_PER_SEC);
 111
 112         addend = neg_adj ? addend - diff : addend + diff;
 113
 114         spin_lock_irqsave(&priv->lock, flags);
 115
 116         priv->ptp.current_addend = addend;
 117
 118         gccr = ravb_read(ndev, GCCR);
 119         if (gccr & GCCR_LTI) {
 120                 spin_unlock_irqrestore(&priv->lock, flags);
 121                 return -EBUSY;
 122         }
 123         ravb_write(ndev, addend & GTI_TIV, GTI);
 124         ravb_write(ndev, gccr | GCCR_LTI, GCCR);
 125
 126         spin_unlock_irqrestore(&priv->lock, flags);
 127
 128         return 0;
 129 }
 130
 131 static int ravb_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 132 {
 133         struct ravb_private *priv = container_of(ptp, struct ravb_private,
 134                                                  ptp.info);
 135         struct timespec64 ts;
 136         unsigned long flags;
 137         int error;
 138
 139         spin_lock_irqsave(&priv->lock, flags);
 140         error = ravb_ptp_time_read(priv, &ts);
 141         if (!error) {
 142                 u64 now = ktime_to_ns(timespec64_to_ktime(ts));
 143
 144                 ts = ns_to_timespec64(now + delta);
 145                 error = ravb_ptp_time_write(priv, &ts);
 146         }
 147         spin_unlock_irqrestore(&priv->lock, flags);
 148
 149         return error;
 150 }
 151
 152 static int ravb_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts)
 153 {
 154         struct ravb_private *priv = container_of(ptp, struct ravb_private,
 155                                                  ptp.info);
 156         unsigned long flags;
 157         int error;
 158
 159         spin_lock_irqsave(&priv->lock, flags);
 160         error = ravb_ptp_time_read(priv, ts);
 161         spin_unlock_irqrestore(&priv->lock, flags);
 162
 163         return error;
 164 }
 165
 166 static int ravb_ptp_settime64(struct ptp_clock_info *ptp,
 167                               const struct timespec64 *ts)
 168 {
 169         struct ravb_private *priv = container_of(ptp, struct ravb_private,
 170                                                  ptp.info);
 171         unsigned long flags;
 172         int error;
 173
 174         spin_lock_irqsave(&priv->lock, flags);
 175         error = ravb_ptp_time_write(priv, ts);
 176         spin_unlock_irqrestore(&priv->lock, flags);
 177
 178         return error;
 179 }
 180
 181 static int ravb_ptp_extts(struct ptp_clock_info *ptp,
 182                           struct ptp_extts_request *req, int on)
 183 {
 184         struct ravb_private *priv = container_of(ptp, struct ravb_private,
 185                                                  ptp.info);
 186         struct net_device *ndev = priv->ndev;
 187         unsigned long flags;
 188         u32 gic;
 189
 190         if (req->index)
 191                 return -EINVAL;
 192
 193         if (priv->ptp.extts[req->index] == on)
 194                 return 0;
 195         priv->ptp.extts[req->index] = on;
 196
 197         spin_lock_irqsave(&priv->lock, flags);
 198         gic = ravb_read(ndev, GIC);
 199         if (on)
 200                 gic |= GIC_PTCE;
 201         else
 202                 gic &= ~GIC_PTCE;
 203         ravb_write(ndev, gic, GIC);
 204         mmiowb();
 205         spin_unlock_irqrestore(&priv->lock, flags);
 206
 207         return 0;
 208 }
 209
 210 static int ravb_ptp_perout(struct ptp_clock_info *ptp,
 211                            struct ptp_perout_request *req, int on)
 212 {
 213         struct ravb_private *priv = container_of(ptp, struct ravb_private,
 214                                                  ptp.info);
 215         struct net_device *ndev = priv->ndev;
 216         struct ravb_ptp_perout *perout;
 217         unsigned long flags;
 218         int error = 0;
 219         u32 gic;
 220
 221         if (req->index)
 222                 return -EINVAL;
 223
 224         if (on) {
 225                 u64 start_ns;
 226                 u64 period_ns;
 227
 228                 start_ns = req->start.sec * NSEC_PER_SEC + req->start.nsec;
 229                 period_ns = req->period.sec * NSEC_PER_SEC + req->period.nsec;
 230
 231                 if (start_ns > U32_MAX) {
 232                         netdev_warn(ndev,
 233                                     "ptp: start value (nsec) is over limit. Maximum size of start is only 32 bits\n");
 234                         return -ERANGE;
 235                 }
 236
 237                 if (period_ns > U32_MAX) {
 238                         netdev_warn(ndev,
 239                                     "ptp: period value (nsec) is over limit. Maximum size of period is only 32 bits\n");
 240                         return -ERANGE;
 241                 }
 242
 243                 spin_lock_irqsave(&priv->lock, flags);
 244
 245                 perout = &priv->ptp.perout[req->index];
 246                 perout->target = (u32)start_ns;
 247                 perout->period = (u32)period_ns;
 248                 error = ravb_ptp_update_compare(priv, (u32)start_ns);
 249                 if (!error) {
 250                         /* Unmask interrupt */
 251                         gic = ravb_read(ndev, GIC);
 252                         gic |= GIC_PTME;
 253                         ravb_write(ndev, gic, GIC);
 254                 }
 255         } else  {
 256                 spin_lock_irqsave(&priv->lock, flags);
 257
 258                 perout = &priv->ptp.perout[req->index];
 259                 perout->period = 0;
 260
 261                 /* Mask interrupt */
 262                 gic = ravb_read(ndev, GIC);
 263                 gic &= ~GIC_PTME;
 264                 ravb_write(ndev, gic, GIC);
 265         }
 266         mmiowb();
 267         spin_unlock_irqrestore(&priv->lock, flags);
 268
 269         return error;
 270 }
 271
 272 static int ravb_ptp_enable(struct ptp_clock_info *ptp,
 273                            struct ptp_clock_request *req, int on)
 274 {
 275         switch (req->type) {
 276         case PTP_CLK_REQ_EXTTS:
 277                 return ravb_ptp_extts(ptp, &req->extts, on);
 278         case PTP_CLK_REQ_PEROUT:
 279                 return ravb_ptp_perout(ptp, &req->perout, on);
 280         default:
 281                 return -EOPNOTSUPP;
 282         }
 283 }
 284
 285 static const struct ptp_clock_info ravb_ptp_info = {
 286         .owner          = THIS_MODULE,
 287         .name           = "ravb clock",
 288         .max_adj        = 50000000,
 289         .n_ext_ts       = N_EXT_TS,
 290         .n_per_out      = N_PER_OUT,
 291         .adjfreq        = ravb_ptp_adjfreq,
 292         .adjtime        = ravb_ptp_adjtime,
 293         .gettime64      = ravb_ptp_gettime64,
 294         .settime64      = ravb_ptp_settime64,
 295         .enable         = ravb_ptp_enable,
 296 };
 297
 298 /* Caller must hold the lock */
 299 irqreturn_t ravb_ptp_interrupt(struct net_device *ndev)
 300 {
 301         struct ravb_private *priv = netdev_priv(ndev);
 302         u32 gis = ravb_read(ndev, GIS);
 303
 304         gis &= ravb_read(ndev, GIC);
 305         if (gis & GIS_PTCF) {
 306                 struct ptp_clock_event event;
 307
 308                 event.type = PTP_CLOCK_EXTTS;
 309                 event.index = 0;
 310                 event.timestamp = ravb_read(ndev, GCPT);
 311                 ptp_clock_event(priv->ptp.clock, &event);
 312         }
 313         if (gis & GIS_PTMF) {
 314                 struct ravb_ptp_perout *perout = priv->ptp.perout;
 315
 316                 if (perout->period) {
 317                         perout->target += perout->period;
 318                         ravb_ptp_update_compare(priv, perout->target);
 319                 }
 320         }
 321
 322         if (gis) {
 323                 ravb_write(ndev, ~gis, GIS);
 324                 return IRQ_HANDLED;
 325         }
 326
 327         return IRQ_NONE;
 328 }
 329
 330 void ravb_ptp_init(struct net_device *ndev, struct platform_device *pdev)
 331 {
 332         struct ravb_private *priv = netdev_priv(ndev);
 333         unsigned long flags;
 334         u32 gccr;
 335
 336         priv->ptp.info = ravb_ptp_info;
 337
 338         priv->ptp.default_addend = ravb_read(ndev, GTI);
 339         priv->ptp.current_addend = priv->ptp.default_addend;
 340
 341         spin_lock_irqsave(&priv->lock, flags);
 342         ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
 343         gccr = ravb_read(ndev, GCCR) & ~GCCR_TCSS;
 344         ravb_write(ndev, gccr | GCCR_TCSS_ADJGPTP, GCCR);
 345         mmiowb();
 346         spin_unlock_irqrestore(&priv->lock, flags);
 347
 348         priv->ptp.clock = ptp_clock_register(&priv->ptp.info, &pdev->dev);
 349 }
 350
 351 void ravb_ptp_stop(struct net_device *ndev)
 352 {
 353         struct ravb_private *priv = netdev_priv(ndev);
 354
 355         ravb_write(ndev, 0, GIC);
 356         ravb_write(ndev, 0, GIS);
 357
 358         ptp_clock_unregister(priv->ptp.clock);
 359 }