drivers/net/dsa/mv88e6xxx/ptp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Marvell 88E6xxx Switch PTP support
   4  *
   5  * Copyright (c) 2008 Marvell Semiconductor
   6  *
   7  * Copyright (c) 2017 National Instruments
   8  *      Erik Hons <erik.hons@ni.com>
   9  *      Brandon Streiff <brandon.streiff@ni.com>
  10  *      Dane Wagner <dane.wagner@ni.com>
  11  */
  12
  13 #include "chip.h"
  14 #include "global2.h"
  15 #include "hwtstamp.h"
  16 #include "ptp.h"
  17
  18 /* Raw timestamps are in units of 8-ns clock periods. */
  19 #define CC_SHIFT        28
  20 #define CC_MULT         (8 << CC_SHIFT)
  21 #define CC_MULT_NUM     (1 << 9)
  22 #define CC_MULT_DEM     15625ULL
  23
  24 #define TAI_EVENT_WORK_INTERVAL msecs_to_jiffies(100)
  25
  26 #define cc_to_chip(cc) container_of(cc, struct mv88e6xxx_chip, tstamp_cc)
  27 #define dw_overflow_to_chip(dw) container_of(dw, struct mv88e6xxx_chip, \
  28                                              overflow_work)
  29 #define dw_tai_event_to_chip(dw) container_of(dw, struct mv88e6xxx_chip, \
  30                                               tai_event_work)
  31
  32 static int mv88e6xxx_tai_read(struct mv88e6xxx_chip *chip, int addr,
  33                               u16 *data, int len)
  34 {
  35         if (!chip->info->ops->avb_ops->tai_read)
  36                 return -EOPNOTSUPP;
  37
  38         return chip->info->ops->avb_ops->tai_read(chip, addr, data, len);
  39 }
  40
  41 static int mv88e6xxx_tai_write(struct mv88e6xxx_chip *chip, int addr, u16 data)
  42 {
  43         if (!chip->info->ops->avb_ops->tai_write)
  44                 return -EOPNOTSUPP;
  45
  46         return chip->info->ops->avb_ops->tai_write(chip, addr, data);
  47 }
  48
  49 /* TODO: places where this are called should be using pinctrl */
  50 static int mv88e6352_set_gpio_func(struct mv88e6xxx_chip *chip, int pin,
  51                                    int func, int input)
  52 {
  53         int err;
  54
  55         if (!chip->info->ops->gpio_ops)
  56                 return -EOPNOTSUPP;
  57
  58         err = chip->info->ops->gpio_ops->set_dir(chip, pin, input);
  59         if (err)
  60                 return err;
  61
  62         return chip->info->ops->gpio_ops->set_pctl(chip, pin, func);
  63 }
  64
  65 static u64 mv88e6352_ptp_clock_read(const struct cyclecounter *cc)
  66 {
  67         struct mv88e6xxx_chip *chip = cc_to_chip(cc);
  68         u16 phc_time[2];
  69         int err;
  70
  71         err = mv88e6xxx_tai_read(chip, MV88E6XXX_TAI_TIME_LO, phc_time,
  72                                  ARRAY_SIZE(phc_time));
  73         if (err)
  74                 return 0;
  75         else
  76                 return ((u32)phc_time[1] << 16) | phc_time[0];
  77 }
  78
  79 static u64 mv88e6165_ptp_clock_read(const struct cyclecounter *cc)
  80 {
  81         struct mv88e6xxx_chip *chip = cc_to_chip(cc);
  82         u16 phc_time[2];
  83         int err;
  84
  85         err = mv88e6xxx_tai_read(chip, MV88E6XXX_PTP_GC_TIME_LO, phc_time,
  86                                  ARRAY_SIZE(phc_time));
  87         if (err)
  88                 return 0;
  89         else
  90                 return ((u32)phc_time[1] << 16) | phc_time[0];
  91 }
  92
  93 /* mv88e6352_config_eventcap - configure TAI event capture
  94  * @event: PTP_CLOCK_PPS (internal) or PTP_CLOCK_EXTTS (external)
  95  * @rising: zero for falling-edge trigger, else rising-edge trigger
  96  *
  97  * This will also reset the capture sequence counter.
  98  */
  99 static int mv88e6352_config_eventcap(struct mv88e6xxx_chip *chip, int event,
 100                                      int rising)
 101 {
 102         u16 global_config;
 103         u16 cap_config;
 104         int err;
 105
 106         chip->evcap_config = MV88E6XXX_TAI_CFG_CAP_OVERWRITE |
 107                              MV88E6XXX_TAI_CFG_CAP_CTR_START;
 108         if (!rising)
 109                 chip->evcap_config |= MV88E6XXX_TAI_CFG_EVREQ_FALLING;
 110
 111         global_config = (chip->evcap_config | chip->trig_config);
 112         err = mv88e6xxx_tai_write(chip, MV88E6XXX_TAI_CFG, global_config);
 113         if (err)
 114                 return err;
 115
 116         if (event == PTP_CLOCK_PPS) {
 117                 cap_config = MV88E6XXX_TAI_EVENT_STATUS_CAP_TRIG;
 118         } else if (event == PTP_CLOCK_EXTTS) {
 119                 /* if STATUS_CAP_TRIG is unset we capture PTP_EVREQ events */
 120                 cap_config = 0;
 121         } else {
 122                 return -EINVAL;
 123         }
 124
 125         /* Write the capture config; this also clears the capture counter */
 126         err = mv88e6xxx_tai_write(chip, MV88E6XXX_TAI_EVENT_STATUS,
 127                                   cap_config);
 128
 129         return err;
 130 }
 131
 132 static void mv88e6352_tai_event_work(struct work_struct *ugly)
 133 {
 134         struct delayed_work *dw = to_delayed_work(ugly);
 135         struct mv88e6xxx_chip *chip = dw_tai_event_to_chip(dw);
 136         struct ptp_clock_event ev;
 137         u16 status[4];
 138         u32 raw_ts;
 139         int err;
 140
 141         mutex_lock(&chip->reg_lock);
 142         err = mv88e6xxx_tai_read(chip, MV88E6XXX_TAI_EVENT_STATUS,
 143                                  status, ARRAY_SIZE(status));
 144         mutex_unlock(&chip->reg_lock);
 145
 146         if (err) {
 147                 dev_err(chip->dev, "failed to read TAI status register\n");
 148                 return;
 149         }
 150         if (status[0] & MV88E6XXX_TAI_EVENT_STATUS_ERROR) {
 151                 dev_warn(chip->dev, "missed event capture\n");
 152                 return;
 153         }
 154         if (!(status[0] & MV88E6XXX_TAI_EVENT_STATUS_VALID))
 155                 goto out;
 156
 157         raw_ts = ((u32)status[2] << 16) | status[1];
 158
 159         /* Clear the valid bit so the next timestamp can come in */
 160         status[0] &= ~MV88E6XXX_TAI_EVENT_STATUS_VALID;
 161         mutex_lock(&chip->reg_lock);
 162         err = mv88e6xxx_tai_write(chip, MV88E6XXX_TAI_EVENT_STATUS, status[0]);
 163         mutex_unlock(&chip->reg_lock);
 164
 165         /* This is an external timestamp */
 166         ev.type = PTP_CLOCK_EXTTS;
 167
 168         /* We only have one timestamping channel. */
 169         ev.index = 0;
 170         mutex_lock(&chip->reg_lock);
 171         ev.timestamp = timecounter_cyc2time(&chip->tstamp_tc, raw_ts);
 172         mutex_unlock(&chip->reg_lock);
 173
 174         ptp_clock_event(chip->ptp_clock, &ev);
 175 out:
 176         schedule_delayed_work(&chip->tai_event_work, TAI_EVENT_WORK_INTERVAL);
 177 }
 178
 179 static int mv88e6xxx_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
 180 {
 181         struct mv88e6xxx_chip *chip = ptp_to_chip(ptp);
 182         int neg_adj = 0;
 183         u32 diff, mult;
 184         u64 adj;
 185
 186         if (scaled_ppm < 0) {
 187                 neg_adj = 1;
 188                 scaled_ppm = -scaled_ppm;
 189         }
 190         mult = CC_MULT;
 191         adj = CC_MULT_NUM;
 192         adj *= scaled_ppm;
 193         diff = div_u64(adj, CC_MULT_DEM);
 194
 195         mutex_lock(&chip->reg_lock);
 196
 197         timecounter_read(&chip->tstamp_tc);
 198         chip->tstamp_cc.mult = neg_adj ? mult - diff : mult + diff;
 199
 200         mutex_unlock(&chip->reg_lock);
 201
 202         return 0;
 203 }
 204
 205 static int mv88e6xxx_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 206 {
 207         struct mv88e6xxx_chip *chip = ptp_to_chip(ptp);
 208
 209         mutex_lock(&chip->reg_lock);
 210         timecounter_adjtime(&chip->tstamp_tc, delta);
 211         mutex_unlock(&chip->reg_lock);
 212
 213         return 0;
 214 }
 215
 216 static int mv88e6xxx_ptp_gettime(struct ptp_clock_info *ptp,
 217                                  struct timespec64 *ts)
 218 {
 219         struct mv88e6xxx_chip *chip = ptp_to_chip(ptp);
 220         u64 ns;
 221
 222         mutex_lock(&chip->reg_lock);
 223         ns = timecounter_read(&chip->tstamp_tc);
 224         mutex_unlock(&chip->reg_lock);
 225
 226         *ts = ns_to_timespec64(ns);
 227
 228         return 0;
 229 }
 230
 231 static int mv88e6xxx_ptp_settime(struct ptp_clock_info *ptp,
 232                                  const struct timespec64 *ts)
 233 {
 234         struct mv88e6xxx_chip *chip = ptp_to_chip(ptp);
 235         u64 ns;
 236
 237         ns = timespec64_to_ns(ts);
 238
 239         mutex_lock(&chip->reg_lock);
 240         timecounter_init(&chip->tstamp_tc, &chip->tstamp_cc, ns);
 241         mutex_unlock(&chip->reg_lock);
 242
 243         return 0;
 244 }
 245
 246 static int mv88e6352_ptp_enable_extts(struct mv88e6xxx_chip *chip,
 247                                       struct ptp_clock_request *rq, int on)
 248 {
 249         int rising = (rq->extts.flags & PTP_RISING_EDGE);
 250         int func;
 251         int pin;
 252         int err;
 253
 254         pin = ptp_find_pin(chip->ptp_clock, PTP_PF_EXTTS, rq->extts.index);
 255
 256         if (pin < 0)
 257                 return -EBUSY;
 258
 259         mutex_lock(&chip->reg_lock);
 260
 261         if (on) {
 262                 func = MV88E6352_G2_SCRATCH_GPIO_PCTL_EVREQ;
 263
 264                 err = mv88e6352_set_gpio_func(chip, pin, func, true);
 265                 if (err)
 266                         goto out;
 267
 268                 schedule_delayed_work(&chip->tai_event_work,
 269                                       TAI_EVENT_WORK_INTERVAL);
 270
 271                 err = mv88e6352_config_eventcap(chip, PTP_CLOCK_EXTTS, rising);
 272         } else {
 273                 func = MV88E6352_G2_SCRATCH_GPIO_PCTL_GPIO;
 274
 275                 err = mv88e6352_set_gpio_func(chip, pin, func, true);
 276
 277                 cancel_delayed_work_sync(&chip->tai_event_work);
 278         }
 279
 280 out:
 281         mutex_unlock(&chip->reg_lock);
 282
 283         return err;
 284 }
 285
 286 static int mv88e6352_ptp_enable(struct ptp_clock_info *ptp,
 287                                 struct ptp_clock_request *rq, int on)
 288 {
 289         struct mv88e6xxx_chip *chip = ptp_to_chip(ptp);
 290
 291         switch (rq->type) {
 292         case PTP_CLK_REQ_EXTTS:
 293                 return mv88e6352_ptp_enable_extts(chip, rq, on);
 294         default:
 295                 return -EOPNOTSUPP;
 296         }
 297 }
 298
 299 static int mv88e6352_ptp_verify(struct ptp_clock_info *ptp, unsigned int pin,
 300                                 enum ptp_pin_function func, unsigned int chan)
 301 {
 302         switch (func) {
 303         case PTP_PF_NONE:
 304         case PTP_PF_EXTTS:
 305                 break;
 306         case PTP_PF_PEROUT:
 307         case PTP_PF_PHYSYNC:
 308                 return -EOPNOTSUPP;
 309         }
 310         return 0;
 311 }
 312
 313 const struct mv88e6xxx_ptp_ops mv88e6352_ptp_ops = {
 314         .clock_read = mv88e6352_ptp_clock_read,
 315         .ptp_enable = mv88e6352_ptp_enable,
 316         .ptp_verify = mv88e6352_ptp_verify,
 317         .event_work = mv88e6352_tai_event_work,
 318         .port_enable = mv88e6352_hwtstamp_port_enable,
 319         .port_disable = mv88e6352_hwtstamp_port_disable,
 320         .n_ext_ts = 1,
 321         .arr0_sts_reg = MV88E6XXX_PORT_PTP_ARR0_STS,
 322         .arr1_sts_reg = MV88E6XXX_PORT_PTP_ARR1_STS,
 323         .dep_sts_reg = MV88E6XXX_PORT_PTP_DEP_STS,
 324         .rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
 325                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
 326                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
 327                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
 328                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
 329                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
 330                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
 331                 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT) |
 332                 (1 << HWTSTAMP_FILTER_PTP_V2_SYNC) |
 333                 (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ),
 334 };
 335
 336 const struct mv88e6xxx_ptp_ops mv88e6165_ptp_ops = {
 337         .clock_read = mv88e6165_ptp_clock_read,
 338         .global_enable = mv88e6165_global_enable,
 339         .global_disable = mv88e6165_global_disable,
 340         .arr0_sts_reg = MV88E6165_PORT_PTP_ARR0_STS,
 341         .arr1_sts_reg = MV88E6165_PORT_PTP_ARR1_STS,
 342         .dep_sts_reg = MV88E6165_PORT_PTP_DEP_STS,
 343         .rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
 344                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
 345                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
 346                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
 347                 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT) |
 348                 (1 << HWTSTAMP_FILTER_PTP_V2_SYNC) |
 349                 (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ),
 350 };
 351
 352 static u64 mv88e6xxx_ptp_clock_read(const struct cyclecounter *cc)
 353 {
 354         struct mv88e6xxx_chip *chip = cc_to_chip(cc);
 355
 356         if (chip->info->ops->ptp_ops->clock_read)
 357                 return chip->info->ops->ptp_ops->clock_read(cc);
 358
 359         return 0;
 360 }
 361
 362 /* With a 125MHz input clock, the 32-bit timestamp counter overflows in ~34.3
 363  * seconds; this task forces periodic reads so that we don't miss any.
 364  */
 365 #define MV88E6XXX_TAI_OVERFLOW_PERIOD (HZ * 16)
 366 static void mv88e6xxx_ptp_overflow_check(struct work_struct *work)
 367 {
 368         struct delayed_work *dw = to_delayed_work(work);
 369         struct mv88e6xxx_chip *chip = dw_overflow_to_chip(dw);
 370         struct timespec64 ts;
 371
 372         mv88e6xxx_ptp_gettime(&chip->ptp_clock_info, &ts);
 373
 374         schedule_delayed_work(&chip->overflow_work,
 375                               MV88E6XXX_TAI_OVERFLOW_PERIOD);
 376 }
 377
 378 int mv88e6xxx_ptp_setup(struct mv88e6xxx_chip *chip)
 379 {
 380         const struct mv88e6xxx_ptp_ops *ptp_ops = chip->info->ops->ptp_ops;
 381         int i;
 382
 383         /* Set up the cycle counter */
 384         memset(&chip->tstamp_cc, 0, sizeof(chip->tstamp_cc));
 385         chip->tstamp_cc.read    = mv88e6xxx_ptp_clock_read;
 386         chip->tstamp_cc.mask    = CYCLECOUNTER_MASK(32);
 387         chip->tstamp_cc.mult    = CC_MULT;
 388         chip->tstamp_cc.shift   = CC_SHIFT;
 389
 390         timecounter_init(&chip->tstamp_tc, &chip->tstamp_cc,
 391                          ktime_to_ns(ktime_get_real()));
 392
 393         INIT_DELAYED_WORK(&chip->overflow_work, mv88e6xxx_ptp_overflow_check);
 394         if (ptp_ops->event_work)
 395                 INIT_DELAYED_WORK(&chip->tai_event_work, ptp_ops->event_work);
 396
 397         chip->ptp_clock_info.owner = THIS_MODULE;
 398         snprintf(chip->ptp_clock_info.name, sizeof(chip->ptp_clock_info.name),
 399                  "%s", dev_name(chip->dev));
 400         chip->ptp_clock_info.max_adj    = 1000000;
 401
 402         chip->ptp_clock_info.n_ext_ts   = ptp_ops->n_ext_ts;
 403         chip->ptp_clock_info.n_per_out  = 0;
 404         chip->ptp_clock_info.n_pins     = mv88e6xxx_num_gpio(chip);
 405         chip->ptp_clock_info.pps        = 0;
 406
 407         for (i = 0; i < chip->ptp_clock_info.n_pins; ++i) {
 408                 struct ptp_pin_desc *ppd = &chip->pin_config[i];
 409
 410                 snprintf(ppd->name, sizeof(ppd->name), "mv88e6xxx_gpio%d", i);
 411                 ppd->index = i;
 412                 ppd->func = PTP_PF_NONE;
 413         }
 414         chip->ptp_clock_info.pin_config = chip->pin_config;
 415
 416         chip->ptp_clock_info.adjfine    = mv88e6xxx_ptp_adjfine;
 417         chip->ptp_clock_info.adjtime    = mv88e6xxx_ptp_adjtime;
 418         chip->ptp_clock_info.gettime64  = mv88e6xxx_ptp_gettime;
 419         chip->ptp_clock_info.settime64  = mv88e6xxx_ptp_settime;
 420         chip->ptp_clock_info.enable     = ptp_ops->ptp_enable;
 421         chip->ptp_clock_info.verify     = ptp_ops->ptp_verify;
 422         chip->ptp_clock_info.do_aux_work = mv88e6xxx_hwtstamp_work;
 423
 424         chip->ptp_clock = ptp_clock_register(&chip->ptp_clock_info, chip->dev);
 425         if (IS_ERR(chip->ptp_clock))
 426                 return PTR_ERR(chip->ptp_clock);
 427
 428         schedule_delayed_work(&chip->overflow_work,
 429                               MV88E6XXX_TAI_OVERFLOW_PERIOD);
 430
 431         return 0;
 432 }
 433
 434 void mv88e6xxx_ptp_free(struct mv88e6xxx_chip *chip)
 435 {
 436         if (chip->ptp_clock) {
 437                 cancel_delayed_work_sync(&chip->overflow_work);
 438                 if (chip->info->ops->ptp_ops->event_work)
 439                         cancel_delayed_work_sync(&chip->tai_event_work);
 440
 441                 ptp_clock_unregister(chip->ptp_clock);
 442                 chip->ptp_clock = NULL;
 443         }
 444 }