1 // SPDX-License-Identifier: GPL-2.0+ 2 3 #include <linux/ptp_classify.h> 4 5 #include "lan966x_main.h" 6 #include "vcap_api.h" 7 #include "vcap_api_client.h" 8 9 #define LAN966X_MAX_PTP_ID 512 10 11 /* Represents 1ppm adjustment in 2^59 format with 6.037735849ns as reference 12 * The value is calculated as following: (1/1000000)/((2^-59)/6.037735849) 13 */ 14 #define LAN966X_1PPM_FORMAT 3480517749723LL 15 16 /* Represents 1ppb adjustment in 2^29 format with 6.037735849ns as reference 17 * The value is calculated as following: (1/1000000000)/((2^59)/6.037735849) 18 */ 19 #define LAN966X_1PPB_FORMAT 3480517749LL 20 21 #define TOD_ACC_PIN 0x7 22 23 /* This represents the base rule ID for the PTP rules that are added in the 24 * VCAP to trap frames to CPU. This number needs to be bigger than the maximum 25 * number of entries that can exist in the VCAP. 26 */ 27 #define LAN966X_VCAP_PTP_RULE_ID 1000000 28 #define LAN966X_VCAP_L2_PTP_TRAP (LAN966X_VCAP_PTP_RULE_ID + 0) 29 #define LAN966X_VCAP_IPV4_EV_PTP_TRAP (LAN966X_VCAP_PTP_RULE_ID + 1) 30 #define LAN966X_VCAP_IPV4_GEN_PTP_TRAP (LAN966X_VCAP_PTP_RULE_ID + 2) 31 #define LAN966X_VCAP_IPV6_EV_PTP_TRAP (LAN966X_VCAP_PTP_RULE_ID + 3) 32 #define LAN966X_VCAP_IPV6_GEN_PTP_TRAP (LAN966X_VCAP_PTP_RULE_ID + 4) 33 34 enum { 35 PTP_PIN_ACTION_IDLE = 0, 36 PTP_PIN_ACTION_LOAD, 37 PTP_PIN_ACTION_SAVE, 38 PTP_PIN_ACTION_CLOCK, 39 PTP_PIN_ACTION_DELTA, 40 PTP_PIN_ACTION_TOD 41 }; 42 43 static u64 lan966x_ptp_get_nominal_value(void) 44 { 45 /* This is the default value that for each system clock, the time of day 46 * is increased. It has the format 5.59 nanosecond. 47 */ 48 return 0x304d4873ecade305; 49 } 50 51 static int lan966x_ptp_add_trap(struct lan966x_port *port, 52 int (*add_ptp_key)(struct vcap_rule *vrule, 53 struct lan966x_port*), 54 u32 rule_id, 55 u16 proto) 56 { 57 struct lan966x *lan966x = port->lan966x; 58 struct vcap_rule *vrule; 59 int err; 60 61 vrule = vcap_get_rule(lan966x->vcap_ctrl, rule_id); 62 if (vrule) { 63 u32 value, mask; 64 65 /* Just modify the ingress port mask and exit */ 66 vcap_rule_get_key_u32(vrule, VCAP_KF_IF_IGR_PORT_MASK, 67 &value, &mask); 68 mask &= ~BIT(port->chip_port); 69 vcap_rule_mod_key_u32(vrule, VCAP_KF_IF_IGR_PORT_MASK, 70 value, mask); 71 72 err = vcap_mod_rule(vrule); 73 goto free_rule; 74 } 75 76 vrule = vcap_alloc_rule(lan966x->vcap_ctrl, port->dev, 77 LAN966X_VCAP_CID_IS2_L0, 78 VCAP_USER_PTP, 0, rule_id); 79 if (IS_ERR(vrule)) 80 return PTR_ERR(vrule); 81 82 err = add_ptp_key(vrule, port); 83 if (err) 84 goto free_rule; 85 86 err = vcap_set_rule_set_actionset(vrule, VCAP_AFS_BASE_TYPE); 87 err |= vcap_rule_add_action_bit(vrule, VCAP_AF_CPU_COPY_ENA, VCAP_BIT_1); 88 err |= vcap_rule_add_action_u32(vrule, VCAP_AF_MASK_MODE, LAN966X_PMM_REPLACE); 89 err |= vcap_val_rule(vrule, proto); 90 if (err) 91 goto free_rule; 92 93 err = vcap_add_rule(vrule); 94 95 free_rule: 96 /* Free the local copy of the rule */ 97 vcap_free_rule(vrule); 98 return err; 99 } 100 101 static int lan966x_ptp_del_trap(struct lan966x_port *port, 102 u32 rule_id) 103 { 104 struct lan966x *lan966x = port->lan966x; 105 struct vcap_rule *vrule; 106 u32 value, mask; 107 int err; 108 109 vrule = vcap_get_rule(lan966x->vcap_ctrl, rule_id); 110 if (!vrule) 111 return -EEXIST; 112 113 vcap_rule_get_key_u32(vrule, VCAP_KF_IF_IGR_PORT_MASK, &value, &mask); 114 mask |= BIT(port->chip_port); 115 116 /* No other port requires this trap, so it is safe to remove it */ 117 if (mask == GENMASK(lan966x->num_phys_ports, 0)) { 118 err = vcap_del_rule(lan966x->vcap_ctrl, port->dev, rule_id); 119 goto free_rule; 120 } 121 122 vcap_rule_mod_key_u32(vrule, VCAP_KF_IF_IGR_PORT_MASK, value, mask); 123 err = vcap_mod_rule(vrule); 124 125 free_rule: 126 vcap_free_rule(vrule); 127 return err; 128 } 129 130 static int lan966x_ptp_add_l2_key(struct vcap_rule *vrule, 131 struct lan966x_port *port) 132 { 133 return vcap_rule_add_key_u32(vrule, VCAP_KF_ETYPE, ETH_P_1588, ~0); 134 } 135 136 static int lan966x_ptp_add_ip_event_key(struct vcap_rule *vrule, 137 struct lan966x_port *port) 138 { 139 return vcap_rule_add_key_u32(vrule, VCAP_KF_L4_DPORT, PTP_EV_PORT, ~0) || 140 vcap_rule_add_key_bit(vrule, VCAP_KF_TCP_IS, VCAP_BIT_0); 141 } 142 143 static int lan966x_ptp_add_ip_general_key(struct vcap_rule *vrule, 144 struct lan966x_port *port) 145 { 146 return vcap_rule_add_key_u32(vrule, VCAP_KF_L4_DPORT, PTP_GEN_PORT, ~0) || 147 vcap_rule_add_key_bit(vrule, VCAP_KF_TCP_IS, VCAP_BIT_0); 148 } 149 150 static int lan966x_ptp_add_l2_rule(struct lan966x_port *port) 151 { 152 return lan966x_ptp_add_trap(port, lan966x_ptp_add_l2_key, 153 LAN966X_VCAP_L2_PTP_TRAP, ETH_P_ALL); 154 } 155 156 static int lan966x_ptp_add_ipv4_rules(struct lan966x_port *port) 157 { 158 int err; 159 160 err = lan966x_ptp_add_trap(port, lan966x_ptp_add_ip_event_key, 161 LAN966X_VCAP_IPV4_EV_PTP_TRAP, ETH_P_IP); 162 if (err) 163 return err; 164 165 err = lan966x_ptp_add_trap(port, lan966x_ptp_add_ip_general_key, 166 LAN966X_VCAP_IPV4_GEN_PTP_TRAP, ETH_P_IP); 167 if (err) 168 lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV4_EV_PTP_TRAP); 169 170 return err; 171 } 172 173 static int lan966x_ptp_add_ipv6_rules(struct lan966x_port *port) 174 { 175 int err; 176 177 err = lan966x_ptp_add_trap(port, lan966x_ptp_add_ip_event_key, 178 LAN966X_VCAP_IPV6_EV_PTP_TRAP, ETH_P_IPV6); 179 if (err) 180 return err; 181 182 err = lan966x_ptp_add_trap(port, lan966x_ptp_add_ip_general_key, 183 LAN966X_VCAP_IPV6_GEN_PTP_TRAP, ETH_P_IPV6); 184 if (err) 185 lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV6_EV_PTP_TRAP); 186 187 return err; 188 } 189 190 static int lan966x_ptp_del_l2_rule(struct lan966x_port *port) 191 { 192 return lan966x_ptp_del_trap(port, LAN966X_VCAP_L2_PTP_TRAP); 193 } 194 195 static int lan966x_ptp_del_ipv4_rules(struct lan966x_port *port) 196 { 197 int err; 198 199 err = lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV4_EV_PTP_TRAP); 200 err |= lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV4_GEN_PTP_TRAP); 201 202 return err; 203 } 204 205 static int lan966x_ptp_del_ipv6_rules(struct lan966x_port *port) 206 { 207 int err; 208 209 err = lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV6_EV_PTP_TRAP); 210 err |= lan966x_ptp_del_trap(port, LAN966X_VCAP_IPV6_GEN_PTP_TRAP); 211 212 return err; 213 } 214 215 static int lan966x_ptp_add_traps(struct lan966x_port *port) 216 { 217 int err; 218 219 err = lan966x_ptp_add_l2_rule(port); 220 if (err) 221 goto err_l2; 222 223 err = lan966x_ptp_add_ipv4_rules(port); 224 if (err) 225 goto err_ipv4; 226 227 err = lan966x_ptp_add_ipv6_rules(port); 228 if (err) 229 goto err_ipv6; 230 231 return err; 232 233 err_ipv6: 234 lan966x_ptp_del_ipv4_rules(port); 235 err_ipv4: 236 lan966x_ptp_del_l2_rule(port); 237 err_l2: 238 return err; 239 } 240 241 int lan966x_ptp_del_traps(struct lan966x_port *port) 242 { 243 int err; 244 245 err = lan966x_ptp_del_l2_rule(port); 246 err |= lan966x_ptp_del_ipv4_rules(port); 247 err |= lan966x_ptp_del_ipv6_rules(port); 248 249 return err; 250 } 251 252 int lan966x_ptp_setup_traps(struct lan966x_port *port, struct ifreq *ifr) 253 { 254 struct hwtstamp_config cfg; 255 256 if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg))) 257 return -EFAULT; 258 259 if (cfg.rx_filter == HWTSTAMP_FILTER_NONE) 260 return lan966x_ptp_del_traps(port); 261 else 262 return lan966x_ptp_add_traps(port); 263 } 264 265 int lan966x_ptp_hwtstamp_set(struct lan966x_port *port, struct ifreq *ifr) 266 { 267 struct lan966x *lan966x = port->lan966x; 268 struct hwtstamp_config cfg; 269 struct lan966x_phc *phc; 270 271 if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg))) 272 return -EFAULT; 273 274 switch (cfg.tx_type) { 275 case HWTSTAMP_TX_ON: 276 port->ptp_cmd = IFH_REW_OP_TWO_STEP_PTP; 277 break; 278 case HWTSTAMP_TX_ONESTEP_SYNC: 279 port->ptp_cmd = IFH_REW_OP_ONE_STEP_PTP; 280 break; 281 case HWTSTAMP_TX_OFF: 282 port->ptp_cmd = IFH_REW_OP_NOOP; 283 break; 284 default: 285 return -ERANGE; 286 } 287 288 switch (cfg.rx_filter) { 289 case HWTSTAMP_FILTER_NONE: 290 break; 291 case HWTSTAMP_FILTER_ALL: 292 case HWTSTAMP_FILTER_PTP_V1_L4_EVENT: 293 case HWTSTAMP_FILTER_PTP_V1_L4_SYNC: 294 case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ: 295 case HWTSTAMP_FILTER_PTP_V2_L4_EVENT: 296 case HWTSTAMP_FILTER_PTP_V2_L4_SYNC: 297 case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ: 298 case HWTSTAMP_FILTER_PTP_V2_L2_EVENT: 299 case HWTSTAMP_FILTER_PTP_V2_L2_SYNC: 300 case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ: 301 case HWTSTAMP_FILTER_PTP_V2_EVENT: 302 case HWTSTAMP_FILTER_PTP_V2_SYNC: 303 case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ: 304 case HWTSTAMP_FILTER_NTP_ALL: 305 cfg.rx_filter = HWTSTAMP_FILTER_ALL; 306 break; 307 default: 308 return -ERANGE; 309 } 310 311 /* Commit back the result & save it */ 312 mutex_lock(&lan966x->ptp_lock); 313 phc = &lan966x->phc[LAN966X_PHC_PORT]; 314 memcpy(&phc->hwtstamp_config, &cfg, sizeof(cfg)); 315 mutex_unlock(&lan966x->ptp_lock); 316 317 return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0; 318 } 319 320 int lan966x_ptp_hwtstamp_get(struct lan966x_port *port, struct ifreq *ifr) 321 { 322 struct lan966x *lan966x = port->lan966x; 323 struct lan966x_phc *phc; 324 325 phc = &lan966x->phc[LAN966X_PHC_PORT]; 326 return copy_to_user(ifr->ifr_data, &phc->hwtstamp_config, 327 sizeof(phc->hwtstamp_config)) ? -EFAULT : 0; 328 } 329 330 static int lan966x_ptp_classify(struct lan966x_port *port, struct sk_buff *skb) 331 { 332 struct ptp_header *header; 333 u8 msgtype; 334 int type; 335 336 if (port->ptp_cmd == IFH_REW_OP_NOOP) 337 return IFH_REW_OP_NOOP; 338 339 type = ptp_classify_raw(skb); 340 if (type == PTP_CLASS_NONE) 341 return IFH_REW_OP_NOOP; 342 343 header = ptp_parse_header(skb, type); 344 if (!header) 345 return IFH_REW_OP_NOOP; 346 347 if (port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) 348 return IFH_REW_OP_TWO_STEP_PTP; 349 350 /* If it is sync and run 1 step then set the correct operation, 351 * otherwise run as 2 step 352 */ 353 msgtype = ptp_get_msgtype(header, type); 354 if ((msgtype & 0xf) == 0) 355 return IFH_REW_OP_ONE_STEP_PTP; 356 357 return IFH_REW_OP_TWO_STEP_PTP; 358 } 359 360 static void lan966x_ptp_txtstamp_old_release(struct lan966x_port *port) 361 { 362 struct sk_buff *skb, *skb_tmp; 363 unsigned long flags; 364 365 spin_lock_irqsave(&port->tx_skbs.lock, flags); 366 skb_queue_walk_safe(&port->tx_skbs, skb, skb_tmp) { 367 if time_after(LAN966X_SKB_CB(skb)->jiffies + LAN966X_PTP_TIMEOUT, 368 jiffies) 369 break; 370 371 __skb_unlink(skb, &port->tx_skbs); 372 dev_kfree_skb_any(skb); 373 } 374 spin_unlock_irqrestore(&port->tx_skbs.lock, flags); 375 } 376 377 int lan966x_ptp_txtstamp_request(struct lan966x_port *port, 378 struct sk_buff *skb) 379 { 380 struct lan966x *lan966x = port->lan966x; 381 unsigned long flags; 382 u8 rew_op; 383 384 rew_op = lan966x_ptp_classify(port, skb); 385 LAN966X_SKB_CB(skb)->rew_op = rew_op; 386 387 if (rew_op != IFH_REW_OP_TWO_STEP_PTP) 388 return 0; 389 390 lan966x_ptp_txtstamp_old_release(port); 391 392 spin_lock_irqsave(&lan966x->ptp_ts_id_lock, flags); 393 if (lan966x->ptp_skbs == LAN966X_MAX_PTP_ID) { 394 spin_unlock_irqrestore(&lan966x->ptp_ts_id_lock, flags); 395 return -EBUSY; 396 } 397 398 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; 399 400 skb_queue_tail(&port->tx_skbs, skb); 401 LAN966X_SKB_CB(skb)->ts_id = port->ts_id; 402 LAN966X_SKB_CB(skb)->jiffies = jiffies; 403 404 lan966x->ptp_skbs++; 405 port->ts_id++; 406 if (port->ts_id == LAN966X_MAX_PTP_ID) 407 port->ts_id = 0; 408 409 spin_unlock_irqrestore(&lan966x->ptp_ts_id_lock, flags); 410 411 return 0; 412 } 413 414 void lan966x_ptp_txtstamp_release(struct lan966x_port *port, 415 struct sk_buff *skb) 416 { 417 struct lan966x *lan966x = port->lan966x; 418 unsigned long flags; 419 420 spin_lock_irqsave(&lan966x->ptp_ts_id_lock, flags); 421 port->ts_id--; 422 lan966x->ptp_skbs--; 423 skb_unlink(skb, &port->tx_skbs); 424 spin_unlock_irqrestore(&lan966x->ptp_ts_id_lock, flags); 425 } 426 427 static void lan966x_get_hwtimestamp(struct lan966x *lan966x, 428 struct timespec64 *ts, 429 u32 nsec) 430 { 431 /* Read current PTP time to get seconds */ 432 unsigned long flags; 433 u32 curr_nsec; 434 435 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 436 437 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_SAVE) | 438 PTP_PIN_CFG_PIN_DOM_SET(LAN966X_PHC_PORT) | 439 PTP_PIN_CFG_PIN_SYNC_SET(0), 440 PTP_PIN_CFG_PIN_ACTION | 441 PTP_PIN_CFG_PIN_DOM | 442 PTP_PIN_CFG_PIN_SYNC, 443 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 444 445 ts->tv_sec = lan_rd(lan966x, PTP_TOD_SEC_LSB(TOD_ACC_PIN)); 446 curr_nsec = lan_rd(lan966x, PTP_TOD_NSEC(TOD_ACC_PIN)); 447 448 ts->tv_nsec = nsec; 449 450 /* Sec has incremented since the ts was registered */ 451 if (curr_nsec < nsec) 452 ts->tv_sec--; 453 454 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 455 } 456 457 irqreturn_t lan966x_ptp_irq_handler(int irq, void *args) 458 { 459 int budget = LAN966X_MAX_PTP_ID; 460 struct lan966x *lan966x = args; 461 462 while (budget--) { 463 struct sk_buff *skb, *skb_tmp, *skb_match = NULL; 464 struct skb_shared_hwtstamps shhwtstamps; 465 struct lan966x_port *port; 466 struct timespec64 ts; 467 unsigned long flags; 468 u32 val, id, txport; 469 u32 delay; 470 471 val = lan_rd(lan966x, PTP_TWOSTEP_CTRL); 472 473 /* Check if a timestamp can be retrieved */ 474 if (!(val & PTP_TWOSTEP_CTRL_VLD)) 475 break; 476 477 WARN_ON(val & PTP_TWOSTEP_CTRL_OVFL); 478 479 if (!(val & PTP_TWOSTEP_CTRL_STAMP_TX)) 480 continue; 481 482 /* Retrieve the ts Tx port */ 483 txport = PTP_TWOSTEP_CTRL_STAMP_PORT_GET(val); 484 485 /* Retrieve its associated skb */ 486 port = lan966x->ports[txport]; 487 488 /* Retrieve the delay */ 489 delay = lan_rd(lan966x, PTP_TWOSTEP_STAMP); 490 delay = PTP_TWOSTEP_STAMP_STAMP_NSEC_GET(delay); 491 492 /* Get next timestamp from fifo, which needs to be the 493 * rx timestamp which represents the id of the frame 494 */ 495 lan_rmw(PTP_TWOSTEP_CTRL_NXT_SET(1), 496 PTP_TWOSTEP_CTRL_NXT, 497 lan966x, PTP_TWOSTEP_CTRL); 498 499 val = lan_rd(lan966x, PTP_TWOSTEP_CTRL); 500 501 /* Check if a timestamp can be retried */ 502 if (!(val & PTP_TWOSTEP_CTRL_VLD)) 503 break; 504 505 /* Read RX timestamping to get the ID */ 506 id = lan_rd(lan966x, PTP_TWOSTEP_STAMP); 507 508 spin_lock_irqsave(&port->tx_skbs.lock, flags); 509 skb_queue_walk_safe(&port->tx_skbs, skb, skb_tmp) { 510 if (LAN966X_SKB_CB(skb)->ts_id != id) 511 continue; 512 513 __skb_unlink(skb, &port->tx_skbs); 514 skb_match = skb; 515 break; 516 } 517 spin_unlock_irqrestore(&port->tx_skbs.lock, flags); 518 519 /* Next ts */ 520 lan_rmw(PTP_TWOSTEP_CTRL_NXT_SET(1), 521 PTP_TWOSTEP_CTRL_NXT, 522 lan966x, PTP_TWOSTEP_CTRL); 523 524 if (WARN_ON(!skb_match)) 525 continue; 526 527 spin_lock(&lan966x->ptp_ts_id_lock); 528 lan966x->ptp_skbs--; 529 spin_unlock(&lan966x->ptp_ts_id_lock); 530 531 /* Get the h/w timestamp */ 532 lan966x_get_hwtimestamp(lan966x, &ts, delay); 533 534 /* Set the timestamp into the skb */ 535 shhwtstamps.hwtstamp = ktime_set(ts.tv_sec, ts.tv_nsec); 536 skb_tstamp_tx(skb_match, &shhwtstamps); 537 538 dev_kfree_skb_any(skb_match); 539 } 540 541 return IRQ_HANDLED; 542 } 543 544 irqreturn_t lan966x_ptp_ext_irq_handler(int irq, void *args) 545 { 546 struct lan966x *lan966x = args; 547 struct lan966x_phc *phc; 548 unsigned long flags; 549 u64 time = 0; 550 time64_t s; 551 int pin, i; 552 s64 ns; 553 554 if (!(lan_rd(lan966x, PTP_PIN_INTR))) 555 return IRQ_NONE; 556 557 /* Go through all domains and see which pin generated the interrupt */ 558 for (i = 0; i < LAN966X_PHC_COUNT; ++i) { 559 struct ptp_clock_event ptp_event = {0}; 560 561 phc = &lan966x->phc[i]; 562 pin = ptp_find_pin_unlocked(phc->clock, PTP_PF_EXTTS, 0); 563 if (pin == -1) 564 continue; 565 566 if (!(lan_rd(lan966x, PTP_PIN_INTR) & BIT(pin))) 567 continue; 568 569 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 570 571 /* Enable to get the new interrupt. 572 * By writing 1 it clears the bit 573 */ 574 lan_wr(BIT(pin), lan966x, PTP_PIN_INTR); 575 576 /* Get current time */ 577 s = lan_rd(lan966x, PTP_TOD_SEC_MSB(pin)); 578 s <<= 32; 579 s |= lan_rd(lan966x, PTP_TOD_SEC_LSB(pin)); 580 ns = lan_rd(lan966x, PTP_TOD_NSEC(pin)); 581 ns &= PTP_TOD_NSEC_TOD_NSEC; 582 583 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 584 585 if ((ns & 0xFFFFFFF0) == 0x3FFFFFF0) { 586 s--; 587 ns &= 0xf; 588 ns += 999999984; 589 } 590 time = ktime_set(s, ns); 591 592 ptp_event.index = pin; 593 ptp_event.timestamp = time; 594 ptp_event.type = PTP_CLOCK_EXTTS; 595 ptp_clock_event(phc->clock, &ptp_event); 596 } 597 598 return IRQ_HANDLED; 599 } 600 601 static int lan966x_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm) 602 { 603 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 604 struct lan966x *lan966x = phc->lan966x; 605 unsigned long flags; 606 bool neg_adj = 0; 607 u64 tod_inc; 608 u64 ref; 609 610 if (!scaled_ppm) 611 return 0; 612 613 if (scaled_ppm < 0) { 614 neg_adj = 1; 615 scaled_ppm = -scaled_ppm; 616 } 617 618 tod_inc = lan966x_ptp_get_nominal_value(); 619 620 /* The multiplication is split in 2 separate additions because of 621 * overflow issues. If scaled_ppm with 16bit fractional part was bigger 622 * than 20ppm then we got overflow. 623 */ 624 ref = LAN966X_1PPM_FORMAT * (scaled_ppm >> 16); 625 ref += (LAN966X_1PPM_FORMAT * (0xffff & scaled_ppm)) >> 16; 626 tod_inc = neg_adj ? tod_inc - ref : tod_inc + ref; 627 628 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 629 630 lan_rmw(PTP_DOM_CFG_CLKCFG_DIS_SET(1 << BIT(phc->index)), 631 PTP_DOM_CFG_CLKCFG_DIS, 632 lan966x, PTP_DOM_CFG); 633 634 lan_wr((u32)tod_inc & 0xFFFFFFFF, lan966x, 635 PTP_CLK_PER_CFG(phc->index, 0)); 636 lan_wr((u32)(tod_inc >> 32), lan966x, 637 PTP_CLK_PER_CFG(phc->index, 1)); 638 639 lan_rmw(PTP_DOM_CFG_CLKCFG_DIS_SET(0), 640 PTP_DOM_CFG_CLKCFG_DIS, 641 lan966x, PTP_DOM_CFG); 642 643 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 644 645 return 0; 646 } 647 648 static int lan966x_ptp_settime64(struct ptp_clock_info *ptp, 649 const struct timespec64 *ts) 650 { 651 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 652 struct lan966x *lan966x = phc->lan966x; 653 unsigned long flags; 654 655 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 656 657 /* Must be in IDLE mode before the time can be loaded */ 658 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_IDLE) | 659 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 660 PTP_PIN_CFG_PIN_SYNC_SET(0), 661 PTP_PIN_CFG_PIN_ACTION | 662 PTP_PIN_CFG_PIN_DOM | 663 PTP_PIN_CFG_PIN_SYNC, 664 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 665 666 /* Set new value */ 667 lan_wr(PTP_TOD_SEC_MSB_TOD_SEC_MSB_SET(upper_32_bits(ts->tv_sec)), 668 lan966x, PTP_TOD_SEC_MSB(TOD_ACC_PIN)); 669 lan_wr(lower_32_bits(ts->tv_sec), 670 lan966x, PTP_TOD_SEC_LSB(TOD_ACC_PIN)); 671 lan_wr(ts->tv_nsec, lan966x, PTP_TOD_NSEC(TOD_ACC_PIN)); 672 673 /* Apply new values */ 674 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_LOAD) | 675 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 676 PTP_PIN_CFG_PIN_SYNC_SET(0), 677 PTP_PIN_CFG_PIN_ACTION | 678 PTP_PIN_CFG_PIN_DOM | 679 PTP_PIN_CFG_PIN_SYNC, 680 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 681 682 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 683 684 return 0; 685 } 686 687 int lan966x_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts) 688 { 689 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 690 struct lan966x *lan966x = phc->lan966x; 691 unsigned long flags; 692 time64_t s; 693 s64 ns; 694 695 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 696 697 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_SAVE) | 698 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 699 PTP_PIN_CFG_PIN_SYNC_SET(0), 700 PTP_PIN_CFG_PIN_ACTION | 701 PTP_PIN_CFG_PIN_DOM | 702 PTP_PIN_CFG_PIN_SYNC, 703 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 704 705 s = lan_rd(lan966x, PTP_TOD_SEC_MSB(TOD_ACC_PIN)); 706 s <<= 32; 707 s |= lan_rd(lan966x, PTP_TOD_SEC_LSB(TOD_ACC_PIN)); 708 ns = lan_rd(lan966x, PTP_TOD_NSEC(TOD_ACC_PIN)); 709 ns &= PTP_TOD_NSEC_TOD_NSEC; 710 711 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 712 713 /* Deal with negative values */ 714 if ((ns & 0xFFFFFFF0) == 0x3FFFFFF0) { 715 s--; 716 ns &= 0xf; 717 ns += 999999984; 718 } 719 720 set_normalized_timespec64(ts, s, ns); 721 return 0; 722 } 723 724 static int lan966x_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) 725 { 726 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 727 struct lan966x *lan966x = phc->lan966x; 728 729 if (delta > -(NSEC_PER_SEC / 2) && delta < (NSEC_PER_SEC / 2)) { 730 unsigned long flags; 731 732 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 733 734 /* Must be in IDLE mode before the time can be loaded */ 735 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_IDLE) | 736 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 737 PTP_PIN_CFG_PIN_SYNC_SET(0), 738 PTP_PIN_CFG_PIN_ACTION | 739 PTP_PIN_CFG_PIN_DOM | 740 PTP_PIN_CFG_PIN_SYNC, 741 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 742 743 lan_wr(PTP_TOD_NSEC_TOD_NSEC_SET(delta), 744 lan966x, PTP_TOD_NSEC(TOD_ACC_PIN)); 745 746 /* Adjust time with the value of PTP_TOD_NSEC */ 747 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_DELTA) | 748 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 749 PTP_PIN_CFG_PIN_SYNC_SET(0), 750 PTP_PIN_CFG_PIN_ACTION | 751 PTP_PIN_CFG_PIN_DOM | 752 PTP_PIN_CFG_PIN_SYNC, 753 lan966x, PTP_PIN_CFG(TOD_ACC_PIN)); 754 755 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 756 } else { 757 /* Fall back using lan966x_ptp_settime64 which is not exact */ 758 struct timespec64 ts; 759 u64 now; 760 761 lan966x_ptp_gettime64(ptp, &ts); 762 763 now = ktime_to_ns(timespec64_to_ktime(ts)); 764 ts = ns_to_timespec64(now + delta); 765 766 lan966x_ptp_settime64(ptp, &ts); 767 } 768 769 return 0; 770 } 771 772 static int lan966x_ptp_verify(struct ptp_clock_info *ptp, unsigned int pin, 773 enum ptp_pin_function func, unsigned int chan) 774 { 775 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 776 struct lan966x *lan966x = phc->lan966x; 777 struct ptp_clock_info *info; 778 int i; 779 780 /* Currently support only 1 channel */ 781 if (chan != 0) 782 return -1; 783 784 switch (func) { 785 case PTP_PF_NONE: 786 case PTP_PF_PEROUT: 787 case PTP_PF_EXTTS: 788 break; 789 default: 790 return -1; 791 } 792 793 /* The PTP pins are shared by all the PHC. So it is required to see if 794 * the pin is connected to another PHC. The pin is connected to another 795 * PHC if that pin already has a function on that PHC. 796 */ 797 for (i = 0; i < LAN966X_PHC_COUNT; ++i) { 798 info = &lan966x->phc[i].info; 799 800 /* Ignore the check with ourself */ 801 if (ptp == info) 802 continue; 803 804 if (info->pin_config[pin].func == PTP_PF_PEROUT || 805 info->pin_config[pin].func == PTP_PF_EXTTS) 806 return -1; 807 } 808 809 return 0; 810 } 811 812 static int lan966x_ptp_perout(struct ptp_clock_info *ptp, 813 struct ptp_clock_request *rq, int on) 814 { 815 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 816 struct lan966x *lan966x = phc->lan966x; 817 struct timespec64 ts_phase, ts_period; 818 unsigned long flags; 819 s64 wf_high, wf_low; 820 bool pps = false; 821 int pin; 822 823 if (rq->perout.flags & ~(PTP_PEROUT_DUTY_CYCLE | 824 PTP_PEROUT_PHASE)) 825 return -EOPNOTSUPP; 826 827 pin = ptp_find_pin(phc->clock, PTP_PF_PEROUT, rq->perout.index); 828 if (pin == -1 || pin >= LAN966X_PHC_PINS_NUM) 829 return -EINVAL; 830 831 if (!on) { 832 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 833 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_IDLE) | 834 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 835 PTP_PIN_CFG_PIN_SYNC_SET(0), 836 PTP_PIN_CFG_PIN_ACTION | 837 PTP_PIN_CFG_PIN_DOM | 838 PTP_PIN_CFG_PIN_SYNC, 839 lan966x, PTP_PIN_CFG(pin)); 840 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 841 return 0; 842 } 843 844 if (rq->perout.period.sec == 1 && 845 rq->perout.period.nsec == 0) 846 pps = true; 847 848 if (rq->perout.flags & PTP_PEROUT_PHASE) { 849 ts_phase.tv_sec = rq->perout.phase.sec; 850 ts_phase.tv_nsec = rq->perout.phase.nsec; 851 } else { 852 ts_phase.tv_sec = rq->perout.start.sec; 853 ts_phase.tv_nsec = rq->perout.start.nsec; 854 } 855 856 if (ts_phase.tv_sec || (ts_phase.tv_nsec && !pps)) { 857 dev_warn(lan966x->dev, 858 "Absolute time not supported!\n"); 859 return -EINVAL; 860 } 861 862 if (rq->perout.flags & PTP_PEROUT_DUTY_CYCLE) { 863 struct timespec64 ts_on; 864 865 ts_on.tv_sec = rq->perout.on.sec; 866 ts_on.tv_nsec = rq->perout.on.nsec; 867 868 wf_high = timespec64_to_ns(&ts_on); 869 } else { 870 wf_high = 5000; 871 } 872 873 if (pps) { 874 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 875 lan_wr(PTP_WF_LOW_PERIOD_PIN_WFL(ts_phase.tv_nsec), 876 lan966x, PTP_WF_LOW_PERIOD(pin)); 877 lan_wr(PTP_WF_HIGH_PERIOD_PIN_WFH(wf_high), 878 lan966x, PTP_WF_HIGH_PERIOD(pin)); 879 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_CLOCK) | 880 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 881 PTP_PIN_CFG_PIN_SYNC_SET(3), 882 PTP_PIN_CFG_PIN_ACTION | 883 PTP_PIN_CFG_PIN_DOM | 884 PTP_PIN_CFG_PIN_SYNC, 885 lan966x, PTP_PIN_CFG(pin)); 886 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 887 return 0; 888 } 889 890 ts_period.tv_sec = rq->perout.period.sec; 891 ts_period.tv_nsec = rq->perout.period.nsec; 892 893 wf_low = timespec64_to_ns(&ts_period); 894 wf_low -= wf_high; 895 896 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 897 lan_wr(PTP_WF_LOW_PERIOD_PIN_WFL(wf_low), 898 lan966x, PTP_WF_LOW_PERIOD(pin)); 899 lan_wr(PTP_WF_HIGH_PERIOD_PIN_WFH(wf_high), 900 lan966x, PTP_WF_HIGH_PERIOD(pin)); 901 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_CLOCK) | 902 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 903 PTP_PIN_CFG_PIN_SYNC_SET(0), 904 PTP_PIN_CFG_PIN_ACTION | 905 PTP_PIN_CFG_PIN_DOM | 906 PTP_PIN_CFG_PIN_SYNC, 907 lan966x, PTP_PIN_CFG(pin)); 908 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 909 910 return 0; 911 } 912 913 static int lan966x_ptp_extts(struct ptp_clock_info *ptp, 914 struct ptp_clock_request *rq, int on) 915 { 916 struct lan966x_phc *phc = container_of(ptp, struct lan966x_phc, info); 917 struct lan966x *lan966x = phc->lan966x; 918 unsigned long flags; 919 int pin; 920 u32 val; 921 922 if (lan966x->ptp_ext_irq <= 0) 923 return -EOPNOTSUPP; 924 925 /* Reject requests with unsupported flags */ 926 if (rq->extts.flags & ~(PTP_ENABLE_FEATURE | 927 PTP_RISING_EDGE | 928 PTP_STRICT_FLAGS)) 929 return -EOPNOTSUPP; 930 931 pin = ptp_find_pin(phc->clock, PTP_PF_EXTTS, rq->extts.index); 932 if (pin == -1 || pin >= LAN966X_PHC_PINS_NUM) 933 return -EINVAL; 934 935 spin_lock_irqsave(&lan966x->ptp_clock_lock, flags); 936 lan_rmw(PTP_PIN_CFG_PIN_ACTION_SET(PTP_PIN_ACTION_SAVE) | 937 PTP_PIN_CFG_PIN_SYNC_SET(on ? 3 : 0) | 938 PTP_PIN_CFG_PIN_DOM_SET(phc->index) | 939 PTP_PIN_CFG_PIN_SELECT_SET(pin), 940 PTP_PIN_CFG_PIN_ACTION | 941 PTP_PIN_CFG_PIN_SYNC | 942 PTP_PIN_CFG_PIN_DOM | 943 PTP_PIN_CFG_PIN_SELECT, 944 lan966x, PTP_PIN_CFG(pin)); 945 946 val = lan_rd(lan966x, PTP_PIN_INTR_ENA); 947 if (on) 948 val |= BIT(pin); 949 else 950 val &= ~BIT(pin); 951 lan_wr(val, lan966x, PTP_PIN_INTR_ENA); 952 953 spin_unlock_irqrestore(&lan966x->ptp_clock_lock, flags); 954 955 return 0; 956 } 957 958 static int lan966x_ptp_enable(struct ptp_clock_info *ptp, 959 struct ptp_clock_request *rq, int on) 960 { 961 switch (rq->type) { 962 case PTP_CLK_REQ_PEROUT: 963 return lan966x_ptp_perout(ptp, rq, on); 964 case PTP_CLK_REQ_EXTTS: 965 return lan966x_ptp_extts(ptp, rq, on); 966 default: 967 return -EOPNOTSUPP; 968 } 969 970 return 0; 971 } 972 973 static struct ptp_clock_info lan966x_ptp_clock_info = { 974 .owner = THIS_MODULE, 975 .name = "lan966x ptp", 976 .max_adj = 200000, 977 .gettime64 = lan966x_ptp_gettime64, 978 .settime64 = lan966x_ptp_settime64, 979 .adjtime = lan966x_ptp_adjtime, 980 .adjfine = lan966x_ptp_adjfine, 981 .verify = lan966x_ptp_verify, 982 .enable = lan966x_ptp_enable, 983 .n_per_out = LAN966X_PHC_PINS_NUM, 984 .n_ext_ts = LAN966X_PHC_PINS_NUM, 985 .n_pins = LAN966X_PHC_PINS_NUM, 986 }; 987 988 static int lan966x_ptp_phc_init(struct lan966x *lan966x, 989 int index, 990 struct ptp_clock_info *clock_info) 991 { 992 struct lan966x_phc *phc = &lan966x->phc[index]; 993 struct ptp_pin_desc *p; 994 int i; 995 996 for (i = 0; i < LAN966X_PHC_PINS_NUM; i++) { 997 p = &phc->pins[i]; 998 999 snprintf(p->name, sizeof(p->name), "pin%d", i); 1000 p->index = i; 1001 p->func = PTP_PF_NONE; 1002 } 1003 1004 phc->info = *clock_info; 1005 phc->info.pin_config = &phc->pins[0]; 1006 phc->clock = ptp_clock_register(&phc->info, lan966x->dev); 1007 if (IS_ERR(phc->clock)) 1008 return PTR_ERR(phc->clock); 1009 1010 phc->index = index; 1011 phc->lan966x = lan966x; 1012 1013 /* PTP Rx stamping is always enabled. */ 1014 phc->hwtstamp_config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT; 1015 1016 return 0; 1017 } 1018 1019 int lan966x_ptp_init(struct lan966x *lan966x) 1020 { 1021 u64 tod_adj = lan966x_ptp_get_nominal_value(); 1022 struct lan966x_port *port; 1023 int err, i; 1024 1025 if (!lan966x->ptp) 1026 return 0; 1027 1028 for (i = 0; i < LAN966X_PHC_COUNT; ++i) { 1029 err = lan966x_ptp_phc_init(lan966x, i, &lan966x_ptp_clock_info); 1030 if (err) 1031 return err; 1032 } 1033 1034 spin_lock_init(&lan966x->ptp_clock_lock); 1035 spin_lock_init(&lan966x->ptp_ts_id_lock); 1036 mutex_init(&lan966x->ptp_lock); 1037 1038 /* Disable master counters */ 1039 lan_wr(PTP_DOM_CFG_ENA_SET(0), lan966x, PTP_DOM_CFG); 1040 1041 /* Configure the nominal TOD increment per clock cycle */ 1042 lan_rmw(PTP_DOM_CFG_CLKCFG_DIS_SET(0x7), 1043 PTP_DOM_CFG_CLKCFG_DIS, 1044 lan966x, PTP_DOM_CFG); 1045 1046 for (i = 0; i < LAN966X_PHC_COUNT; ++i) { 1047 lan_wr((u32)tod_adj & 0xFFFFFFFF, lan966x, 1048 PTP_CLK_PER_CFG(i, 0)); 1049 lan_wr((u32)(tod_adj >> 32), lan966x, 1050 PTP_CLK_PER_CFG(i, 1)); 1051 } 1052 1053 lan_rmw(PTP_DOM_CFG_CLKCFG_DIS_SET(0), 1054 PTP_DOM_CFG_CLKCFG_DIS, 1055 lan966x, PTP_DOM_CFG); 1056 1057 /* Enable master counters */ 1058 lan_wr(PTP_DOM_CFG_ENA_SET(0x7), lan966x, PTP_DOM_CFG); 1059 1060 for (i = 0; i < lan966x->num_phys_ports; i++) { 1061 port = lan966x->ports[i]; 1062 if (!port) 1063 continue; 1064 1065 skb_queue_head_init(&port->tx_skbs); 1066 } 1067 1068 return 0; 1069 } 1070 1071 void lan966x_ptp_deinit(struct lan966x *lan966x) 1072 { 1073 struct lan966x_port *port; 1074 int i; 1075 1076 for (i = 0; i < lan966x->num_phys_ports; i++) { 1077 port = lan966x->ports[i]; 1078 if (!port) 1079 continue; 1080 1081 skb_queue_purge(&port->tx_skbs); 1082 } 1083 1084 for (i = 0; i < LAN966X_PHC_COUNT; ++i) 1085 ptp_clock_unregister(lan966x->phc[i].clock); 1086 } 1087 1088 void lan966x_ptp_rxtstamp(struct lan966x *lan966x, struct sk_buff *skb, 1089 u64 timestamp) 1090 { 1091 struct skb_shared_hwtstamps *shhwtstamps; 1092 struct lan966x_phc *phc; 1093 struct timespec64 ts; 1094 u64 full_ts_in_ns; 1095 1096 if (!lan966x->ptp) 1097 return; 1098 1099 phc = &lan966x->phc[LAN966X_PHC_PORT]; 1100 lan966x_ptp_gettime64(&phc->info, &ts); 1101 1102 /* Drop the sub-ns precision */ 1103 timestamp = timestamp >> 2; 1104 if (ts.tv_nsec < timestamp) 1105 ts.tv_sec--; 1106 ts.tv_nsec = timestamp; 1107 full_ts_in_ns = ktime_set(ts.tv_sec, ts.tv_nsec); 1108 1109 shhwtstamps = skb_hwtstamps(skb); 1110 shhwtstamps->hwtstamp = full_ts_in_ns; 1111 } 1112 1113 u32 lan966x_ptp_get_period_ps(void) 1114 { 1115 /* This represents the system clock period in picoseconds */ 1116 return 15125; 1117 } 1118