drivers/net/ethernet/mscc/ocelot_ptp.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 /* Microsemi Ocelot PTP clock driver
   3  *
   4  * Copyright (c) 2017 Microsemi Corporation
   5  * Copyright 2020 NXP
   6  */
   7 #include <linux/time64.h>
   8
   9 #include <linux/dsa/ocelot.h>
  10 #include <linux/ptp_classify.h>
  11 #include <soc/mscc/ocelot_ptp.h>
  12 #include <soc/mscc/ocelot_sys.h>
  13 #include <soc/mscc/ocelot_vcap.h>
  14 #include <soc/mscc/ocelot.h>
  15 #include "ocelot.h"
  16
  17 int ocelot_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts)
  18 {
  19         struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
  20         unsigned long flags;
  21         time64_t s;
  22         u32 val;
  23         s64 ns;
  24
  25         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
  26
  27         val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  28         val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
  29         val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_SAVE);
  30         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
  31
  32         s = ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_MSB, TOD_ACC_PIN) & 0xffff;
  33         s <<= 32;
  34         s += ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);
  35         ns = ocelot_read_rix(ocelot, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);
  36
  37         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
  38
  39         /* Deal with negative values */
  40         if (ns >= 0x3ffffff0 && ns <= 0x3fffffff) {
  41                 s--;
  42                 ns &= 0xf;
  43                 ns += 999999984;
  44         }
  45
  46         set_normalized_timespec64(ts, s, ns);
  47         return 0;
  48 }
  49 EXPORT_SYMBOL(ocelot_ptp_gettime64);
  50
  51 int ocelot_ptp_settime64(struct ptp_clock_info *ptp,
  52                          const struct timespec64 *ts)
  53 {
  54         struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
  55         unsigned long flags;
  56         u32 val;
  57
  58         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
  59
  60         val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  61         val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
  62         val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);
  63
  64         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
  65
  66         ocelot_write_rix(ocelot, lower_32_bits(ts->tv_sec), PTP_PIN_TOD_SEC_LSB,
  67                          TOD_ACC_PIN);
  68         ocelot_write_rix(ocelot, upper_32_bits(ts->tv_sec), PTP_PIN_TOD_SEC_MSB,
  69                          TOD_ACC_PIN);
  70         ocelot_write_rix(ocelot, ts->tv_nsec, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);
  71
  72         val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  73         val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
  74         val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_LOAD);
  75
  76         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
  77
  78         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
  79
  80         if (ocelot->ops->tas_clock_adjust)
  81                 ocelot->ops->tas_clock_adjust(ocelot);
  82
  83         return 0;
  84 }
  85 EXPORT_SYMBOL(ocelot_ptp_settime64);
  86
  87 int ocelot_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
  88 {
  89         if (delta > -(NSEC_PER_SEC / 2) && delta < (NSEC_PER_SEC / 2)) {
  90                 struct ocelot *ocelot = container_of(ptp, struct ocelot,
  91                                                      ptp_info);
  92                 unsigned long flags;
  93                 u32 val;
  94
  95                 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
  96
  97                 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  98                 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK |
  99                          PTP_PIN_CFG_DOM);
 100                 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);
 101
 102                 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
 103
 104                 ocelot_write_rix(ocelot, 0, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);
 105                 ocelot_write_rix(ocelot, 0, PTP_PIN_TOD_SEC_MSB, TOD_ACC_PIN);
 106                 ocelot_write_rix(ocelot, delta, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);
 107
 108                 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
 109                 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK |
 110                          PTP_PIN_CFG_DOM);
 111                 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_DELTA);
 112
 113                 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
 114
 115                 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 116
 117                 if (ocelot->ops->tas_clock_adjust)
 118                         ocelot->ops->tas_clock_adjust(ocelot);
 119         } else {
 120                 /* Fall back using ocelot_ptp_settime64 which is not exact. */
 121                 struct timespec64 ts;
 122                 u64 now;
 123
 124                 ocelot_ptp_gettime64(ptp, &ts);
 125
 126                 now = ktime_to_ns(timespec64_to_ktime(ts));
 127                 ts = ns_to_timespec64(now + delta);
 128
 129                 ocelot_ptp_settime64(ptp, &ts);
 130         }
 131
 132         return 0;
 133 }
 134 EXPORT_SYMBOL(ocelot_ptp_adjtime);
 135
 136 int ocelot_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
 137 {
 138         struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 139         u32 unit = 0, direction = 0;
 140         unsigned long flags;
 141         u64 adj = 0;
 142
 143         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
 144
 145         if (!scaled_ppm)
 146                 goto disable_adj;
 147
 148         if (scaled_ppm < 0) {
 149                 direction = PTP_CFG_CLK_ADJ_CFG_DIR;
 150                 scaled_ppm = -scaled_ppm;
 151         }
 152
 153         adj = PSEC_PER_SEC << 16;
 154         do_div(adj, scaled_ppm);
 155         do_div(adj, 1000);
 156
 157         /* If the adjustment value is too large, use ns instead */
 158         if (adj >= (1L << 30)) {
 159                 unit = PTP_CFG_CLK_ADJ_FREQ_NS;
 160                 do_div(adj, 1000);
 161         }
 162
 163         /* Still too big */
 164         if (adj >= (1L << 30))
 165                 goto disable_adj;
 166
 167         ocelot_write(ocelot, unit | adj, PTP_CLK_CFG_ADJ_FREQ);
 168         ocelot_write(ocelot, PTP_CFG_CLK_ADJ_CFG_ENA | direction,
 169                      PTP_CLK_CFG_ADJ_CFG);
 170
 171         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 172         return 0;
 173
 174 disable_adj:
 175         ocelot_write(ocelot, 0, PTP_CLK_CFG_ADJ_CFG);
 176
 177         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 178         return 0;
 179 }
 180 EXPORT_SYMBOL(ocelot_ptp_adjfine);
 181
 182 int ocelot_ptp_verify(struct ptp_clock_info *ptp, unsigned int pin,
 183                       enum ptp_pin_function func, unsigned int chan)
 184 {
 185         switch (func) {
 186         case PTP_PF_NONE:
 187         case PTP_PF_PEROUT:
 188                 break;
 189         case PTP_PF_EXTTS:
 190         case PTP_PF_PHYSYNC:
 191                 return -1;
 192         }
 193         return 0;
 194 }
 195 EXPORT_SYMBOL(ocelot_ptp_verify);
 196
 197 int ocelot_ptp_enable(struct ptp_clock_info *ptp,
 198                       struct ptp_clock_request *rq, int on)
 199 {
 200         struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 201         struct timespec64 ts_phase, ts_period;
 202         enum ocelot_ptp_pins ptp_pin;
 203         unsigned long flags;
 204         bool pps = false;
 205         int pin = -1;
 206         s64 wf_high;
 207         s64 wf_low;
 208         u32 val;
 209
 210         switch (rq->type) {
 211         case PTP_CLK_REQ_PEROUT:
 212                 /* Reject requests with unsupported flags */
 213                 if (rq->perout.flags & ~(PTP_PEROUT_DUTY_CYCLE |
 214                                          PTP_PEROUT_PHASE))
 215                         return -EOPNOTSUPP;
 216
 217                 pin = ptp_find_pin(ocelot->ptp_clock, PTP_PF_PEROUT,
 218                                    rq->perout.index);
 219                 if (pin == 0)
 220                         ptp_pin = PTP_PIN_0;
 221                 else if (pin == 1)
 222                         ptp_pin = PTP_PIN_1;
 223                 else if (pin == 2)
 224                         ptp_pin = PTP_PIN_2;
 225                 else if (pin == 3)
 226                         ptp_pin = PTP_PIN_3;
 227                 else
 228                         return -EBUSY;
 229
 230                 ts_period.tv_sec = rq->perout.period.sec;
 231                 ts_period.tv_nsec = rq->perout.period.nsec;
 232
 233                 if (ts_period.tv_sec == 1 && ts_period.tv_nsec == 0)
 234                         pps = true;
 235
 236                 /* Handle turning off */
 237                 if (!on) {
 238                         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
 239                         val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);
 240                         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
 241                         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 242                         break;
 243                 }
 244
 245                 if (rq->perout.flags & PTP_PEROUT_PHASE) {
 246                         ts_phase.tv_sec = rq->perout.phase.sec;
 247                         ts_phase.tv_nsec = rq->perout.phase.nsec;
 248                 } else {
 249                         /* Compatibility */
 250                         ts_phase.tv_sec = rq->perout.start.sec;
 251                         ts_phase.tv_nsec = rq->perout.start.nsec;
 252                 }
 253                 if (ts_phase.tv_sec || (ts_phase.tv_nsec && !pps)) {
 254                         dev_warn(ocelot->dev,
 255                                  "Absolute start time not supported!\n");
 256                         dev_warn(ocelot->dev,
 257                                  "Accept nsec for PPS phase adjustment, otherwise start time should be 0 0.\n");
 258                         return -EINVAL;
 259                 }
 260
 261                 /* Calculate waveform high and low times */
 262                 if (rq->perout.flags & PTP_PEROUT_DUTY_CYCLE) {
 263                         struct timespec64 ts_on;
 264
 265                         ts_on.tv_sec = rq->perout.on.sec;
 266                         ts_on.tv_nsec = rq->perout.on.nsec;
 267
 268                         wf_high = timespec64_to_ns(&ts_on);
 269                 } else {
 270                         if (pps) {
 271                                 wf_high = 1000;
 272                         } else {
 273                                 wf_high = timespec64_to_ns(&ts_period);
 274                                 wf_high = div_s64(wf_high, 2);
 275                         }
 276                 }
 277
 278                 wf_low = timespec64_to_ns(&ts_period);
 279                 wf_low -= wf_high;
 280
 281                 /* Handle PPS request */
 282                 if (pps) {
 283                         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
 284                         ocelot_write_rix(ocelot, ts_phase.tv_nsec,
 285                                          PTP_PIN_WF_LOW_PERIOD, ptp_pin);
 286                         ocelot_write_rix(ocelot, wf_high,
 287                                          PTP_PIN_WF_HIGH_PERIOD, ptp_pin);
 288                         val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_CLOCK);
 289                         val |= PTP_PIN_CFG_SYNC;
 290                         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
 291                         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 292                         break;
 293                 }
 294
 295                 /* Handle periodic clock */
 296                 if (wf_high > 0x3fffffff || wf_high <= 0x6)
 297                         return -EINVAL;
 298                 if (wf_low > 0x3fffffff || wf_low <= 0x6)
 299                         return -EINVAL;
 300
 301                 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
 302                 ocelot_write_rix(ocelot, wf_low, PTP_PIN_WF_LOW_PERIOD,
 303                                  ptp_pin);
 304                 ocelot_write_rix(ocelot, wf_high, PTP_PIN_WF_HIGH_PERIOD,
 305                                  ptp_pin);
 306                 val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_CLOCK);
 307                 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
 308                 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 309                 break;
 310         default:
 311                 return -EOPNOTSUPP;
 312         }
 313         return 0;
 314 }
 315 EXPORT_SYMBOL(ocelot_ptp_enable);
 316
 317 static void ocelot_populate_l2_ptp_trap_key(struct ocelot_vcap_filter *trap)
 318 {
 319         trap->key_type = OCELOT_VCAP_KEY_ETYPE;
 320         *(__be16 *)trap->key.etype.etype.value = htons(ETH_P_1588);
 321         *(__be16 *)trap->key.etype.etype.mask = htons(0xffff);
 322 }
 323
 324 static void
 325 ocelot_populate_ipv4_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
 326 {
 327         trap->key_type = OCELOT_VCAP_KEY_IPV4;
 328         trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
 329         trap->key.ipv4.proto.mask[0] = 0xff;
 330         trap->key.ipv4.dport.value = PTP_EV_PORT;
 331         trap->key.ipv4.dport.mask = 0xffff;
 332 }
 333
 334 static void
 335 ocelot_populate_ipv6_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
 336 {
 337         trap->key_type = OCELOT_VCAP_KEY_IPV6;
 338         trap->key.ipv6.proto.value[0] = IPPROTO_UDP;
 339         trap->key.ipv6.proto.mask[0] = 0xff;
 340         trap->key.ipv6.dport.value = PTP_EV_PORT;
 341         trap->key.ipv6.dport.mask = 0xffff;
 342 }
 343
 344 static void
 345 ocelot_populate_ipv4_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
 346 {
 347         trap->key_type = OCELOT_VCAP_KEY_IPV4;
 348         trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
 349         trap->key.ipv4.proto.mask[0] = 0xff;
 350         trap->key.ipv4.dport.value = PTP_GEN_PORT;
 351         trap->key.ipv4.dport.mask = 0xffff;
 352 }
 353
 354 static void
 355 ocelot_populate_ipv6_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
 356 {
 357         trap->key_type = OCELOT_VCAP_KEY_IPV6;
 358         trap->key.ipv6.proto.value[0] = IPPROTO_UDP;
 359         trap->key.ipv6.proto.mask[0] = 0xff;
 360         trap->key.ipv6.dport.value = PTP_GEN_PORT;
 361         trap->key.ipv6.dport.mask = 0xffff;
 362 }
 363
 364 static int ocelot_l2_ptp_trap_add(struct ocelot *ocelot, int port)
 365 {
 366         unsigned long l2_cookie = OCELOT_VCAP_IS2_L2_PTP_TRAP(ocelot);
 367
 368         return ocelot_trap_add(ocelot, port, l2_cookie, true,
 369                                ocelot_populate_l2_ptp_trap_key);
 370 }
 371
 372 static int ocelot_l2_ptp_trap_del(struct ocelot *ocelot, int port)
 373 {
 374         unsigned long l2_cookie = OCELOT_VCAP_IS2_L2_PTP_TRAP(ocelot);
 375
 376         return ocelot_trap_del(ocelot, port, l2_cookie);
 377 }
 378
 379 static int ocelot_ipv4_ptp_trap_add(struct ocelot *ocelot, int port)
 380 {
 381         unsigned long ipv4_gen_cookie = OCELOT_VCAP_IS2_IPV4_GEN_PTP_TRAP(ocelot);
 382         unsigned long ipv4_ev_cookie = OCELOT_VCAP_IS2_IPV4_EV_PTP_TRAP(ocelot);
 383         int err;
 384
 385         err = ocelot_trap_add(ocelot, port, ipv4_ev_cookie, true,
 386                               ocelot_populate_ipv4_ptp_event_trap_key);
 387         if (err)
 388                 return err;
 389
 390         err = ocelot_trap_add(ocelot, port, ipv4_gen_cookie, false,
 391                               ocelot_populate_ipv4_ptp_general_trap_key);
 392         if (err)
 393                 ocelot_trap_del(ocelot, port, ipv4_ev_cookie);
 394
 395         return err;
 396 }
 397
 398 static int ocelot_ipv4_ptp_trap_del(struct ocelot *ocelot, int port)
 399 {
 400         unsigned long ipv4_gen_cookie = OCELOT_VCAP_IS2_IPV4_GEN_PTP_TRAP(ocelot);
 401         unsigned long ipv4_ev_cookie = OCELOT_VCAP_IS2_IPV4_EV_PTP_TRAP(ocelot);
 402         int err;
 403
 404         err = ocelot_trap_del(ocelot, port, ipv4_ev_cookie);
 405         err |= ocelot_trap_del(ocelot, port, ipv4_gen_cookie);
 406         return err;
 407 }
 408
 409 static int ocelot_ipv6_ptp_trap_add(struct ocelot *ocelot, int port)
 410 {
 411         unsigned long ipv6_gen_cookie = OCELOT_VCAP_IS2_IPV6_GEN_PTP_TRAP(ocelot);
 412         unsigned long ipv6_ev_cookie = OCELOT_VCAP_IS2_IPV6_EV_PTP_TRAP(ocelot);
 413         int err;
 414
 415         err = ocelot_trap_add(ocelot, port, ipv6_ev_cookie, true,
 416                               ocelot_populate_ipv6_ptp_event_trap_key);
 417         if (err)
 418                 return err;
 419
 420         err = ocelot_trap_add(ocelot, port, ipv6_gen_cookie, false,
 421                               ocelot_populate_ipv6_ptp_general_trap_key);
 422         if (err)
 423                 ocelot_trap_del(ocelot, port, ipv6_ev_cookie);
 424
 425         return err;
 426 }
 427
 428 static int ocelot_ipv6_ptp_trap_del(struct ocelot *ocelot, int port)
 429 {
 430         unsigned long ipv6_gen_cookie = OCELOT_VCAP_IS2_IPV6_GEN_PTP_TRAP(ocelot);
 431         unsigned long ipv6_ev_cookie = OCELOT_VCAP_IS2_IPV6_EV_PTP_TRAP(ocelot);
 432         int err;
 433
 434         err = ocelot_trap_del(ocelot, port, ipv6_ev_cookie);
 435         err |= ocelot_trap_del(ocelot, port, ipv6_gen_cookie);
 436         return err;
 437 }
 438
 439 static int ocelot_setup_ptp_traps(struct ocelot *ocelot, int port,
 440                                   bool l2, bool l4)
 441 {
 442         struct ocelot_port *ocelot_port = ocelot->ports[port];
 443         int err;
 444
 445         ocelot_port->trap_proto &= ~(OCELOT_PROTO_PTP_L2 |
 446                                      OCELOT_PROTO_PTP_L4);
 447
 448         if (l2)
 449                 err = ocelot_l2_ptp_trap_add(ocelot, port);
 450         else
 451                 err = ocelot_l2_ptp_trap_del(ocelot, port);
 452         if (err)
 453                 return err;
 454
 455         if (l4) {
 456                 err = ocelot_ipv4_ptp_trap_add(ocelot, port);
 457                 if (err)
 458                         goto err_ipv4;
 459
 460                 err = ocelot_ipv6_ptp_trap_add(ocelot, port);
 461                 if (err)
 462                         goto err_ipv6;
 463         } else {
 464                 err = ocelot_ipv4_ptp_trap_del(ocelot, port);
 465
 466                 err |= ocelot_ipv6_ptp_trap_del(ocelot, port);
 467         }
 468         if (err)
 469                 return err;
 470
 471         if (l2)
 472                 ocelot_port->trap_proto |= OCELOT_PROTO_PTP_L2;
 473         if (l4)
 474                 ocelot_port->trap_proto |= OCELOT_PROTO_PTP_L4;
 475
 476         return 0;
 477
 478 err_ipv6:
 479         ocelot_ipv4_ptp_trap_del(ocelot, port);
 480 err_ipv4:
 481         if (l2)
 482                 ocelot_l2_ptp_trap_del(ocelot, port);
 483         return err;
 484 }
 485
 486 static int ocelot_traps_to_ptp_rx_filter(unsigned int proto)
 487 {
 488         if ((proto & OCELOT_PROTO_PTP_L2) && (proto & OCELOT_PROTO_PTP_L4))
 489                 return HWTSTAMP_FILTER_PTP_V2_EVENT;
 490         else if (proto & OCELOT_PROTO_PTP_L2)
 491                 return HWTSTAMP_FILTER_PTP_V2_L2_EVENT;
 492         else if (proto & OCELOT_PROTO_PTP_L4)
 493                 return HWTSTAMP_FILTER_PTP_V2_L4_EVENT;
 494
 495         return HWTSTAMP_FILTER_NONE;
 496 }
 497
 498 int ocelot_hwstamp_get(struct ocelot *ocelot, int port, struct ifreq *ifr)
 499 {
 500         struct ocelot_port *ocelot_port = ocelot->ports[port];
 501         struct hwtstamp_config cfg = {};
 502
 503         switch (ocelot_port->ptp_cmd) {
 504         case IFH_REW_OP_TWO_STEP_PTP:
 505                 cfg.tx_type = HWTSTAMP_TX_ON;
 506                 break;
 507         case IFH_REW_OP_ORIGIN_PTP:
 508                 cfg.tx_type = HWTSTAMP_TX_ONESTEP_SYNC;
 509                 break;
 510         default:
 511                 cfg.tx_type = HWTSTAMP_TX_OFF;
 512                 break;
 513         }
 514
 515         cfg.rx_filter = ocelot_traps_to_ptp_rx_filter(ocelot_port->trap_proto);
 516
 517         return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
 518 }
 519 EXPORT_SYMBOL(ocelot_hwstamp_get);
 520
 521 int ocelot_hwstamp_set(struct ocelot *ocelot, int port, struct ifreq *ifr)
 522 {
 523         struct ocelot_port *ocelot_port = ocelot->ports[port];
 524         bool l2 = false, l4 = false;
 525         struct hwtstamp_config cfg;
 526         int err;
 527
 528         if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
 529                 return -EFAULT;
 530
 531         /* Tx type sanity check */
 532         switch (cfg.tx_type) {
 533         case HWTSTAMP_TX_ON:
 534                 ocelot_port->ptp_cmd = IFH_REW_OP_TWO_STEP_PTP;
 535                 break;
 536         case HWTSTAMP_TX_ONESTEP_SYNC:
 537                 /* IFH_REW_OP_ONE_STEP_PTP updates the correctional field, we
 538                  * need to update the origin time.
 539                  */
 540                 ocelot_port->ptp_cmd = IFH_REW_OP_ORIGIN_PTP;
 541                 break;
 542         case HWTSTAMP_TX_OFF:
 543                 ocelot_port->ptp_cmd = 0;
 544                 break;
 545         default:
 546                 return -ERANGE;
 547         }
 548
 549         switch (cfg.rx_filter) {
 550         case HWTSTAMP_FILTER_NONE:
 551                 break;
 552         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
 553         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
 554         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
 555                 l4 = true;
 556                 break;
 557         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
 558         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
 559         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
 560                 l2 = true;
 561                 break;
 562         case HWTSTAMP_FILTER_PTP_V2_EVENT:
 563         case HWTSTAMP_FILTER_PTP_V2_SYNC:
 564         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
 565                 l2 = true;
 566                 l4 = true;
 567                 break;
 568         default:
 569                 return -ERANGE;
 570         }
 571
 572         err = ocelot_setup_ptp_traps(ocelot, port, l2, l4);
 573         if (err)
 574                 return err;
 575
 576         cfg.rx_filter = ocelot_traps_to_ptp_rx_filter(ocelot_port->trap_proto);
 577
 578         return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
 579 }
 580 EXPORT_SYMBOL(ocelot_hwstamp_set);
 581
 582 int ocelot_get_ts_info(struct ocelot *ocelot, int port,
 583                        struct ethtool_ts_info *info)
 584 {
 585         info->phc_index = ocelot->ptp_clock ?
 586                           ptp_clock_index(ocelot->ptp_clock) : -1;
 587         if (info->phc_index == -1) {
 588                 info->so_timestamping |= SOF_TIMESTAMPING_TX_SOFTWARE |
 589                                          SOF_TIMESTAMPING_RX_SOFTWARE |
 590                                          SOF_TIMESTAMPING_SOFTWARE;
 591                 return 0;
 592         }
 593         info->so_timestamping |= SOF_TIMESTAMPING_TX_SOFTWARE |
 594                                  SOF_TIMESTAMPING_RX_SOFTWARE |
 595                                  SOF_TIMESTAMPING_SOFTWARE |
 596                                  SOF_TIMESTAMPING_TX_HARDWARE |
 597                                  SOF_TIMESTAMPING_RX_HARDWARE |
 598                                  SOF_TIMESTAMPING_RAW_HARDWARE;
 599         info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON) |
 600                          BIT(HWTSTAMP_TX_ONESTEP_SYNC);
 601         info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
 602                            BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
 603                            BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
 604                            BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT);
 605
 606         return 0;
 607 }
 608 EXPORT_SYMBOL(ocelot_get_ts_info);
 609
 610 static int ocelot_port_add_txtstamp_skb(struct ocelot *ocelot, int port,
 611                                         struct sk_buff *clone)
 612 {
 613         struct ocelot_port *ocelot_port = ocelot->ports[port];
 614         unsigned long flags;
 615
 616         spin_lock_irqsave(&ocelot->ts_id_lock, flags);
 617
 618         if (ocelot_port->ptp_skbs_in_flight == OCELOT_MAX_PTP_ID ||
 619             ocelot->ptp_skbs_in_flight == OCELOT_PTP_FIFO_SIZE) {
 620                 spin_unlock_irqrestore(&ocelot->ts_id_lock, flags);
 621                 return -EBUSY;
 622         }
 623
 624         skb_shinfo(clone)->tx_flags |= SKBTX_IN_PROGRESS;
 625         /* Store timestamp ID in OCELOT_SKB_CB(clone)->ts_id */
 626         OCELOT_SKB_CB(clone)->ts_id = ocelot_port->ts_id;
 627
 628         ocelot_port->ts_id++;
 629         if (ocelot_port->ts_id == OCELOT_MAX_PTP_ID)
 630                 ocelot_port->ts_id = 0;
 631
 632         ocelot_port->ptp_skbs_in_flight++;
 633         ocelot->ptp_skbs_in_flight++;
 634
 635         skb_queue_tail(&ocelot_port->tx_skbs, clone);
 636
 637         spin_unlock_irqrestore(&ocelot->ts_id_lock, flags);
 638
 639         return 0;
 640 }
 641
 642 static bool ocelot_ptp_is_onestep_sync(struct sk_buff *skb,
 643                                        unsigned int ptp_class)
 644 {
 645         struct ptp_header *hdr;
 646         u8 msgtype, twostep;
 647
 648         hdr = ptp_parse_header(skb, ptp_class);
 649         if (!hdr)
 650                 return false;
 651
 652         msgtype = ptp_get_msgtype(hdr, ptp_class);
 653         twostep = hdr->flag_field[0] & 0x2;
 654
 655         if (msgtype == PTP_MSGTYPE_SYNC && twostep == 0)
 656                 return true;
 657
 658         return false;
 659 }
 660
 661 int ocelot_port_txtstamp_request(struct ocelot *ocelot, int port,
 662                                  struct sk_buff *skb,
 663                                  struct sk_buff **clone)
 664 {
 665         struct ocelot_port *ocelot_port = ocelot->ports[port];
 666         u8 ptp_cmd = ocelot_port->ptp_cmd;
 667         unsigned int ptp_class;
 668         int err;
 669
 670         /* Don't do anything if PTP timestamping not enabled */
 671         if (!ptp_cmd)
 672                 return 0;
 673
 674         ptp_class = ptp_classify_raw(skb);
 675         if (ptp_class == PTP_CLASS_NONE)
 676                 return -EINVAL;
 677
 678         /* Store ptp_cmd in OCELOT_SKB_CB(skb)->ptp_cmd */
 679         if (ptp_cmd == IFH_REW_OP_ORIGIN_PTP) {
 680                 if (ocelot_ptp_is_onestep_sync(skb, ptp_class)) {
 681                         OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd;
 682                         return 0;
 683                 }
 684
 685                 /* Fall back to two-step timestamping */
 686                 ptp_cmd = IFH_REW_OP_TWO_STEP_PTP;
 687         }
 688
 689         if (ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
 690                 *clone = skb_clone_sk(skb);
 691                 if (!(*clone))
 692                         return -ENOMEM;
 693
 694                 err = ocelot_port_add_txtstamp_skb(ocelot, port, *clone);
 695                 if (err)
 696                         return err;
 697
 698                 OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd;
 699                 OCELOT_SKB_CB(*clone)->ptp_class = ptp_class;
 700         }
 701
 702         return 0;
 703 }
 704 EXPORT_SYMBOL(ocelot_port_txtstamp_request);
 705
 706 static void ocelot_get_hwtimestamp(struct ocelot *ocelot,
 707                                    struct timespec64 *ts)
 708 {
 709         unsigned long flags;
 710         u32 val;
 711
 712         spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
 713
 714         /* Read current PTP time to get seconds */
 715         val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
 716
 717         val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
 718         val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_SAVE);
 719         ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
 720         ts->tv_sec = ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);
 721
 722         /* Read packet HW timestamp from FIFO */
 723         val = ocelot_read(ocelot, SYS_PTP_TXSTAMP);
 724         ts->tv_nsec = SYS_PTP_TXSTAMP_PTP_TXSTAMP(val);
 725
 726         /* Sec has incremented since the ts was registered */
 727         if ((ts->tv_sec & 0x1) != !!(val & SYS_PTP_TXSTAMP_PTP_TXSTAMP_SEC))
 728                 ts->tv_sec--;
 729
 730         spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 731 }
 732
 733 static bool ocelot_validate_ptp_skb(struct sk_buff *clone, u16 seqid)
 734 {
 735         struct ptp_header *hdr;
 736
 737         hdr = ptp_parse_header(clone, OCELOT_SKB_CB(clone)->ptp_class);
 738         if (WARN_ON(!hdr))
 739                 return false;
 740
 741         return seqid == ntohs(hdr->sequence_id);
 742 }
 743
 744 void ocelot_get_txtstamp(struct ocelot *ocelot)
 745 {
 746         int budget = OCELOT_PTP_QUEUE_SZ;
 747
 748         while (budget--) {
 749                 struct sk_buff *skb, *skb_tmp, *skb_match = NULL;
 750                 struct skb_shared_hwtstamps shhwtstamps;
 751                 u32 val, id, seqid, txport;
 752                 struct ocelot_port *port;
 753                 struct timespec64 ts;
 754                 unsigned long flags;
 755
 756                 val = ocelot_read(ocelot, SYS_PTP_STATUS);
 757
 758                 /* Check if a timestamp can be retrieved */
 759                 if (!(val & SYS_PTP_STATUS_PTP_MESS_VLD))
 760                         break;
 761
 762                 WARN_ON(val & SYS_PTP_STATUS_PTP_OVFL);
 763
 764                 /* Retrieve the ts ID and Tx port */
 765                 id = SYS_PTP_STATUS_PTP_MESS_ID_X(val);
 766                 txport = SYS_PTP_STATUS_PTP_MESS_TXPORT_X(val);
 767                 seqid = SYS_PTP_STATUS_PTP_MESS_SEQ_ID(val);
 768
 769                 port = ocelot->ports[txport];
 770
 771                 spin_lock(&ocelot->ts_id_lock);
 772                 port->ptp_skbs_in_flight--;
 773                 ocelot->ptp_skbs_in_flight--;
 774                 spin_unlock(&ocelot->ts_id_lock);
 775
 776                 /* Retrieve its associated skb */
 777 try_again:
 778                 spin_lock_irqsave(&port->tx_skbs.lock, flags);
 779
 780                 skb_queue_walk_safe(&port->tx_skbs, skb, skb_tmp) {
 781                         if (OCELOT_SKB_CB(skb)->ts_id != id)
 782                                 continue;
 783                         __skb_unlink(skb, &port->tx_skbs);
 784                         skb_match = skb;
 785                         break;
 786                 }
 787
 788                 spin_unlock_irqrestore(&port->tx_skbs.lock, flags);
 789
 790                 if (WARN_ON(!skb_match))
 791                         continue;
 792
 793                 if (!ocelot_validate_ptp_skb(skb_match, seqid)) {
 794                         dev_err_ratelimited(ocelot->dev,
 795                                             "port %d received stale TX timestamp for seqid %d, discarding\n",
 796                                             txport, seqid);
 797                         dev_kfree_skb_any(skb);
 798                         goto try_again;
 799                 }
 800
 801                 /* Get the h/w timestamp */
 802                 ocelot_get_hwtimestamp(ocelot, &ts);
 803
 804                 /* Set the timestamp into the skb */
 805                 memset(&shhwtstamps, 0, sizeof(shhwtstamps));
 806                 shhwtstamps.hwtstamp = ktime_set(ts.tv_sec, ts.tv_nsec);
 807                 skb_complete_tx_timestamp(skb_match, &shhwtstamps);
 808
 809                 /* Next ts */
 810                 ocelot_write(ocelot, SYS_PTP_NXT_PTP_NXT, SYS_PTP_NXT);
 811         }
 812 }
 813 EXPORT_SYMBOL(ocelot_get_txtstamp);
 814
 815 int ocelot_init_timestamp(struct ocelot *ocelot,
 816                           const struct ptp_clock_info *info)
 817 {
 818         struct ptp_clock *ptp_clock;
 819         int i;
 820
 821         ocelot->ptp_info = *info;
 822
 823         for (i = 0; i < OCELOT_PTP_PINS_NUM; i++) {
 824                 struct ptp_pin_desc *p = &ocelot->ptp_pins[i];
 825
 826                 snprintf(p->name, sizeof(p->name), "switch_1588_dat%d", i);
 827                 p->index = i;
 828                 p->func = PTP_PF_NONE;
 829         }
 830
 831         ocelot->ptp_info.pin_config = &ocelot->ptp_pins[0];
 832
 833         ptp_clock = ptp_clock_register(&ocelot->ptp_info, ocelot->dev);
 834         if (IS_ERR(ptp_clock))
 835                 return PTR_ERR(ptp_clock);
 836         /* Check if PHC support is missing at the configuration level */
 837         if (!ptp_clock)
 838                 return 0;
 839
 840         ocelot->ptp_clock = ptp_clock;
 841
 842         ocelot_write(ocelot, SYS_PTP_CFG_PTP_STAMP_WID(30), SYS_PTP_CFG);
 843         ocelot_write(ocelot, 0xffffffff, ANA_TABLES_PTP_ID_LOW);
 844         ocelot_write(ocelot, 0xffffffff, ANA_TABLES_PTP_ID_HIGH);
 845
 846         ocelot_write(ocelot, PTP_CFG_MISC_PTP_EN, PTP_CFG_MISC);
 847
 848         return 0;
 849 }
 850 EXPORT_SYMBOL(ocelot_init_timestamp);
 851
 852 int ocelot_deinit_timestamp(struct ocelot *ocelot)
 853 {
 854         if (ocelot->ptp_clock)
 855                 ptp_clock_unregister(ocelot->ptp_clock);
 856         return 0;
 857 }
 858 EXPORT_SYMBOL(ocelot_deinit_timestamp);