1 /* Broadcom NetXtreme-C/E network driver.
3 * Copyright (c) 2021 Broadcom Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation.
9 #include <linux/kernel.h>
10 #include <linux/errno.h>
11 #include <linux/pci.h>
12 #include <linux/netdevice.h>
13 #include <linux/etherdevice.h>
14 #include <linux/net_tstamp.h>
15 #include <linux/timekeeping.h>
16 #include <linux/ptp_classify.h>
17 #include <linux/clocksource.h>
20 #include "bnxt_hwrm.h"
23 static int bnxt_ptp_cfg_settime(struct bnxt *bp, u64 time)
25 struct hwrm_func_ptp_cfg_input *req;
28 rc = hwrm_req_init(bp, req, HWRM_FUNC_PTP_CFG);
32 req->enables = cpu_to_le16(FUNC_PTP_CFG_REQ_ENABLES_PTP_SET_TIME);
33 req->ptp_set_time = cpu_to_le64(time);
34 return hwrm_req_send(bp, req);
37 int bnxt_ptp_parse(struct sk_buff *skb, u16 *seq_id, u16 *hdr_off)
39 unsigned int ptp_class;
40 struct ptp_header *hdr;
42 ptp_class = ptp_classify_raw(skb);
44 switch (ptp_class & PTP_CLASS_VMASK) {
47 hdr = ptp_parse_header(skb, ptp_class);
51 *hdr_off = (u8 *)hdr - skb->data;
52 *seq_id = ntohs(hdr->sequence_id);
59 static int bnxt_ptp_settime(struct ptp_clock_info *ptp_info,
60 const struct timespec64 *ts)
62 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
64 u64 ns = timespec64_to_ns(ts);
66 if (BNXT_PTP_USE_RTC(ptp->bp))
67 return bnxt_ptp_cfg_settime(ptp->bp, ns);
69 spin_lock_bh(&ptp->ptp_lock);
70 timecounter_init(&ptp->tc, &ptp->cc, ns);
71 spin_unlock_bh(&ptp->ptp_lock);
75 /* Caller holds ptp_lock */
76 static int bnxt_refclk_read(struct bnxt *bp, struct ptp_system_timestamp *sts,
79 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
80 u32 high_before, high_now, low;
82 if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state))
85 high_before = readl(bp->bar0 + ptp->refclk_mapped_regs[1]);
86 ptp_read_system_prets(sts);
87 low = readl(bp->bar0 + ptp->refclk_mapped_regs[0]);
88 ptp_read_system_postts(sts);
89 high_now = readl(bp->bar0 + ptp->refclk_mapped_regs[1]);
90 if (high_now != high_before) {
91 ptp_read_system_prets(sts);
92 low = readl(bp->bar0 + ptp->refclk_mapped_regs[0]);
93 ptp_read_system_postts(sts);
95 *ns = ((u64)high_now << 32) | low;
100 static void bnxt_ptp_get_current_time(struct bnxt *bp)
102 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
106 spin_lock_bh(&ptp->ptp_lock);
107 WRITE_ONCE(ptp->old_time, ptp->current_time);
108 bnxt_refclk_read(bp, NULL, &ptp->current_time);
109 spin_unlock_bh(&ptp->ptp_lock);
112 static int bnxt_hwrm_port_ts_query(struct bnxt *bp, u32 flags, u64 *ts)
114 struct hwrm_port_ts_query_output *resp;
115 struct hwrm_port_ts_query_input *req;
118 rc = hwrm_req_init(bp, req, HWRM_PORT_TS_QUERY);
122 req->flags = cpu_to_le32(flags);
123 if ((flags & PORT_TS_QUERY_REQ_FLAGS_PATH) ==
124 PORT_TS_QUERY_REQ_FLAGS_PATH_TX) {
125 req->enables = cpu_to_le16(BNXT_PTP_QTS_TX_ENABLES);
126 req->ptp_seq_id = cpu_to_le32(bp->ptp_cfg->tx_seqid);
127 req->ptp_hdr_offset = cpu_to_le16(bp->ptp_cfg->tx_hdr_off);
128 req->ts_req_timeout = cpu_to_le16(BNXT_PTP_QTS_TIMEOUT);
130 resp = hwrm_req_hold(bp, req);
132 rc = hwrm_req_send(bp, req);
134 *ts = le64_to_cpu(resp->ptp_msg_ts);
135 hwrm_req_drop(bp, req);
139 static int bnxt_ptp_gettimex(struct ptp_clock_info *ptp_info,
140 struct timespec64 *ts,
141 struct ptp_system_timestamp *sts)
143 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
148 spin_lock_bh(&ptp->ptp_lock);
149 rc = bnxt_refclk_read(ptp->bp, sts, &cycles);
151 spin_unlock_bh(&ptp->ptp_lock);
154 ns = timecounter_cyc2time(&ptp->tc, cycles);
155 spin_unlock_bh(&ptp->ptp_lock);
156 *ts = ns_to_timespec64(ns);
161 /* Caller holds ptp_lock */
162 void bnxt_ptp_update_current_time(struct bnxt *bp)
164 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
166 bnxt_refclk_read(ptp->bp, NULL, &ptp->current_time);
167 WRITE_ONCE(ptp->old_time, ptp->current_time);
170 static int bnxt_ptp_adjphc(struct bnxt_ptp_cfg *ptp, s64 delta)
172 struct hwrm_port_mac_cfg_input *req;
175 rc = hwrm_req_init(ptp->bp, req, HWRM_PORT_MAC_CFG);
179 req->enables = cpu_to_le32(PORT_MAC_CFG_REQ_ENABLES_PTP_ADJ_PHASE);
180 req->ptp_adj_phase = cpu_to_le64(delta);
182 rc = hwrm_req_send(ptp->bp, req);
184 netdev_err(ptp->bp->dev, "ptp adjphc failed. rc = %x\n", rc);
186 spin_lock_bh(&ptp->ptp_lock);
187 bnxt_ptp_update_current_time(ptp->bp);
188 spin_unlock_bh(&ptp->ptp_lock);
194 static int bnxt_ptp_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
196 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
199 if (BNXT_PTP_USE_RTC(ptp->bp))
200 return bnxt_ptp_adjphc(ptp, delta);
202 spin_lock_bh(&ptp->ptp_lock);
203 timecounter_adjtime(&ptp->tc, delta);
204 spin_unlock_bh(&ptp->ptp_lock);
208 static int bnxt_ptp_adjfine_rtc(struct bnxt *bp, long scaled_ppm)
210 s32 ppb = scaled_ppm_to_ppb(scaled_ppm);
211 struct hwrm_port_mac_cfg_input *req;
214 rc = hwrm_req_init(bp, req, HWRM_PORT_MAC_CFG);
218 req->ptp_freq_adj_ppb = cpu_to_le32(ppb);
219 req->enables = cpu_to_le32(PORT_MAC_CFG_REQ_ENABLES_PTP_FREQ_ADJ_PPB);
220 rc = hwrm_req_send(bp, req);
223 "ptp adjfine failed. rc = %d\n", rc);
227 static int bnxt_ptp_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm)
229 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
231 struct bnxt *bp = ptp->bp;
234 return bnxt_ptp_adjfine_rtc(bp, scaled_ppm);
236 spin_lock_bh(&ptp->ptp_lock);
237 timecounter_read(&ptp->tc);
238 ptp->cc.mult = adjust_by_scaled_ppm(ptp->cmult, scaled_ppm);
239 spin_unlock_bh(&ptp->ptp_lock);
243 void bnxt_ptp_pps_event(struct bnxt *bp, u32 data1, u32 data2)
245 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
246 struct ptp_clock_event event;
249 pps_ts = EVENT_PPS_TS(data2, data1);
250 spin_lock_bh(&ptp->ptp_lock);
251 ns = timecounter_cyc2time(&ptp->tc, pps_ts);
252 spin_unlock_bh(&ptp->ptp_lock);
254 switch (EVENT_DATA2_PPS_EVENT_TYPE(data2)) {
255 case ASYNC_EVENT_CMPL_PPS_TIMESTAMP_EVENT_DATA2_EVENT_TYPE_INTERNAL:
256 event.pps_times.ts_real = ns_to_timespec64(ns);
257 event.type = PTP_CLOCK_PPSUSR;
258 event.index = EVENT_DATA2_PPS_PIN_NUM(data2);
260 case ASYNC_EVENT_CMPL_PPS_TIMESTAMP_EVENT_DATA2_EVENT_TYPE_EXTERNAL:
261 event.timestamp = ns;
262 event.type = PTP_CLOCK_EXTTS;
263 event.index = EVENT_DATA2_PPS_PIN_NUM(data2);
267 ptp_clock_event(bp->ptp_cfg->ptp_clock, &event);
270 static int bnxt_ptp_cfg_pin(struct bnxt *bp, u8 pin, u8 usage)
272 struct hwrm_func_ptp_pin_cfg_input *req;
273 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
274 u8 state = usage != BNXT_PPS_PIN_NONE;
275 u8 *pin_state, *pin_usg;
279 if (!TSIO_PIN_VALID(pin)) {
280 netdev_err(ptp->bp->dev, "1PPS: Invalid pin. Check pin-function configuration\n");
284 rc = hwrm_req_init(ptp->bp, req, HWRM_FUNC_PTP_PIN_CFG);
288 enables = (FUNC_PTP_PIN_CFG_REQ_ENABLES_PIN0_STATE |
289 FUNC_PTP_PIN_CFG_REQ_ENABLES_PIN0_USAGE) << (pin * 2);
290 req->enables = cpu_to_le32(enables);
292 pin_state = &req->pin0_state;
293 pin_usg = &req->pin0_usage;
295 *(pin_state + (pin * 2)) = state;
296 *(pin_usg + (pin * 2)) = usage;
298 rc = hwrm_req_send(ptp->bp, req);
302 ptp->pps_info.pins[pin].usage = usage;
303 ptp->pps_info.pins[pin].state = state;
308 static int bnxt_ptp_cfg_event(struct bnxt *bp, u8 event)
310 struct hwrm_func_ptp_cfg_input *req;
313 rc = hwrm_req_init(bp, req, HWRM_FUNC_PTP_CFG);
317 req->enables = cpu_to_le16(FUNC_PTP_CFG_REQ_ENABLES_PTP_PPS_EVENT);
318 req->ptp_pps_event = event;
319 return hwrm_req_send(bp, req);
322 void bnxt_ptp_cfg_tstamp_filters(struct bnxt *bp)
324 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
325 struct hwrm_port_mac_cfg_input *req;
327 if (!ptp || !ptp->tstamp_filters)
330 if (hwrm_req_init(bp, req, HWRM_PORT_MAC_CFG))
333 if (!(bp->fw_cap & BNXT_FW_CAP_RX_ALL_PKT_TS) && (ptp->tstamp_filters &
334 (PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_ENABLE |
335 PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_DISABLE))) {
336 ptp->tstamp_filters &= ~(PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_ENABLE |
337 PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_DISABLE);
338 netdev_warn(bp->dev, "Unsupported FW for all RX pkts timestamp filter\n");
341 req->flags = cpu_to_le32(ptp->tstamp_filters);
342 req->enables = cpu_to_le32(PORT_MAC_CFG_REQ_ENABLES_RX_TS_CAPTURE_PTP_MSG_TYPE);
343 req->rx_ts_capture_ptp_msg_type = cpu_to_le16(ptp->rxctl);
345 if (!hwrm_req_send(bp, req)) {
346 bp->ptp_all_rx_tstamp = !!(ptp->tstamp_filters &
347 PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_ENABLE);
350 ptp->tstamp_filters = 0;
352 bp->ptp_all_rx_tstamp = 0;
353 netdev_warn(bp->dev, "Failed to configure HW packet timestamp filters\n");
356 void bnxt_ptp_reapply_pps(struct bnxt *bp)
358 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
359 struct bnxt_pps *pps;
363 if (!ptp || !(bp->fw_cap & BNXT_FW_CAP_PTP_PPS) ||
364 !(ptp->ptp_info.pin_config))
366 pps = &ptp->pps_info;
367 for (pin = 0; pin < BNXT_MAX_TSIO_PINS; pin++) {
368 if (pps->pins[pin].state) {
369 rc = bnxt_ptp_cfg_pin(bp, pin, pps->pins[pin].usage);
370 if (!rc && pps->pins[pin].event)
371 rc = bnxt_ptp_cfg_event(bp,
372 pps->pins[pin].event);
374 netdev_err(bp->dev, "1PPS: Failed to configure pin%d\n",
380 static int bnxt_get_target_cycles(struct bnxt_ptp_cfg *ptp, u64 target_ns,
384 u64 nsec_now, nsec_delta;
387 spin_lock_bh(&ptp->ptp_lock);
388 rc = bnxt_refclk_read(ptp->bp, NULL, &cycles_now);
390 spin_unlock_bh(&ptp->ptp_lock);
393 nsec_now = timecounter_cyc2time(&ptp->tc, cycles_now);
394 spin_unlock_bh(&ptp->ptp_lock);
396 nsec_delta = target_ns - nsec_now;
397 *cycles_delta = div64_u64(nsec_delta << ptp->cc.shift, ptp->cc.mult);
401 static int bnxt_ptp_perout_cfg(struct bnxt_ptp_cfg *ptp,
402 struct ptp_clock_request *rq)
404 struct hwrm_func_ptp_cfg_input *req;
405 struct bnxt *bp = ptp->bp;
406 struct timespec64 ts;
407 u64 target_ns, delta;
411 ts.tv_sec = rq->perout.start.sec;
412 ts.tv_nsec = rq->perout.start.nsec;
413 target_ns = timespec64_to_ns(&ts);
415 rc = bnxt_get_target_cycles(ptp, target_ns, &delta);
419 rc = hwrm_req_init(bp, req, HWRM_FUNC_PTP_CFG);
423 enables = FUNC_PTP_CFG_REQ_ENABLES_PTP_FREQ_ADJ_EXT_PERIOD |
424 FUNC_PTP_CFG_REQ_ENABLES_PTP_FREQ_ADJ_EXT_UP |
425 FUNC_PTP_CFG_REQ_ENABLES_PTP_FREQ_ADJ_EXT_PHASE;
426 req->enables = cpu_to_le16(enables);
427 req->ptp_pps_event = 0;
428 req->ptp_freq_adj_dll_source = 0;
429 req->ptp_freq_adj_dll_phase = 0;
430 req->ptp_freq_adj_ext_period = cpu_to_le32(NSEC_PER_SEC);
431 req->ptp_freq_adj_ext_up = 0;
432 req->ptp_freq_adj_ext_phase_lower = cpu_to_le32(delta);
434 return hwrm_req_send(bp, req);
437 static int bnxt_ptp_enable(struct ptp_clock_info *ptp_info,
438 struct ptp_clock_request *rq, int on)
440 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
442 struct bnxt *bp = ptp->bp;
447 case PTP_CLK_REQ_EXTTS:
448 /* Configure an External PPS IN */
449 pin_id = ptp_find_pin(ptp->ptp_clock, PTP_PF_EXTTS,
451 if (!TSIO_PIN_VALID(pin_id))
455 rc = bnxt_ptp_cfg_pin(bp, pin_id, BNXT_PPS_PIN_PPS_IN);
458 rc = bnxt_ptp_cfg_event(bp, BNXT_PPS_EVENT_EXTERNAL);
460 ptp->pps_info.pins[pin_id].event = BNXT_PPS_EVENT_EXTERNAL;
462 case PTP_CLK_REQ_PEROUT:
463 /* Configure a Periodic PPS OUT */
464 pin_id = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT,
466 if (!TSIO_PIN_VALID(pin_id))
471 rc = bnxt_ptp_cfg_pin(bp, pin_id, BNXT_PPS_PIN_PPS_OUT);
473 rc = bnxt_ptp_perout_cfg(ptp, rq);
476 case PTP_CLK_REQ_PPS:
477 /* Configure PHC PPS IN */
478 rc = bnxt_ptp_cfg_pin(bp, 0, BNXT_PPS_PIN_PPS_IN);
481 rc = bnxt_ptp_cfg_event(bp, BNXT_PPS_EVENT_INTERNAL);
483 ptp->pps_info.pins[0].event = BNXT_PPS_EVENT_INTERNAL;
486 netdev_err(ptp->bp->dev, "Unrecognized PIN function\n");
490 return bnxt_ptp_cfg_pin(bp, pin_id, BNXT_PPS_PIN_NONE);
493 static int bnxt_hwrm_ptp_cfg(struct bnxt *bp)
495 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
499 switch (ptp->rx_filter) {
500 case HWTSTAMP_FILTER_ALL:
501 flags = PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_ENABLE;
503 case HWTSTAMP_FILTER_NONE:
504 flags = PORT_MAC_CFG_REQ_FLAGS_PTP_RX_TS_CAPTURE_DISABLE;
505 if (bp->fw_cap & BNXT_FW_CAP_RX_ALL_PKT_TS)
506 flags |= PORT_MAC_CFG_REQ_FLAGS_ALL_RX_TS_CAPTURE_DISABLE;
508 case HWTSTAMP_FILTER_PTP_V2_EVENT:
509 case HWTSTAMP_FILTER_PTP_V2_SYNC:
510 case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
511 flags = PORT_MAC_CFG_REQ_FLAGS_PTP_RX_TS_CAPTURE_ENABLE;
515 if (ptp->tx_tstamp_en)
516 flags |= PORT_MAC_CFG_REQ_FLAGS_PTP_TX_TS_CAPTURE_ENABLE;
518 flags |= PORT_MAC_CFG_REQ_FLAGS_PTP_TX_TS_CAPTURE_DISABLE;
520 ptp->tstamp_filters = flags;
522 if (netif_running(bp->dev)) {
523 if (ptp->rx_filter == HWTSTAMP_FILTER_ALL) {
524 rc = bnxt_close_nic(bp, false, false);
526 rc = bnxt_open_nic(bp, false, false);
528 bnxt_ptp_cfg_tstamp_filters(bp);
530 if (!rc && !ptp->tstamp_filters)
537 int bnxt_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
539 struct bnxt *bp = netdev_priv(dev);
540 struct hwtstamp_config stmpconf;
541 struct bnxt_ptp_cfg *ptp;
543 int old_rx_filter, rc;
550 if (copy_from_user(&stmpconf, ifr->ifr_data, sizeof(stmpconf)))
553 if (stmpconf.tx_type != HWTSTAMP_TX_ON &&
554 stmpconf.tx_type != HWTSTAMP_TX_OFF)
557 old_rx_filter = ptp->rx_filter;
558 old_rxctl = ptp->rxctl;
559 old_tx_tstamp_en = ptp->tx_tstamp_en;
560 switch (stmpconf.rx_filter) {
561 case HWTSTAMP_FILTER_NONE:
563 ptp->rx_filter = HWTSTAMP_FILTER_NONE;
565 case HWTSTAMP_FILTER_ALL:
566 if (bp->fw_cap & BNXT_FW_CAP_RX_ALL_PKT_TS) {
567 ptp->rx_filter = HWTSTAMP_FILTER_ALL;
571 case HWTSTAMP_FILTER_PTP_V2_EVENT:
572 case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
573 case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
574 ptp->rxctl = BNXT_PTP_MSG_EVENTS;
575 ptp->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
577 case HWTSTAMP_FILTER_PTP_V2_SYNC:
578 case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
579 case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
580 ptp->rxctl = BNXT_PTP_MSG_SYNC;
581 ptp->rx_filter = HWTSTAMP_FILTER_PTP_V2_SYNC;
583 case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
584 case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
585 case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
586 ptp->rxctl = BNXT_PTP_MSG_DELAY_REQ;
587 ptp->rx_filter = HWTSTAMP_FILTER_PTP_V2_DELAY_REQ;
593 if (stmpconf.tx_type == HWTSTAMP_TX_ON)
594 ptp->tx_tstamp_en = 1;
596 ptp->tx_tstamp_en = 0;
598 rc = bnxt_hwrm_ptp_cfg(bp);
602 stmpconf.rx_filter = ptp->rx_filter;
603 return copy_to_user(ifr->ifr_data, &stmpconf, sizeof(stmpconf)) ?
607 ptp->rx_filter = old_rx_filter;
608 ptp->rxctl = old_rxctl;
609 ptp->tx_tstamp_en = old_tx_tstamp_en;
613 int bnxt_hwtstamp_get(struct net_device *dev, struct ifreq *ifr)
615 struct bnxt *bp = netdev_priv(dev);
616 struct hwtstamp_config stmpconf;
617 struct bnxt_ptp_cfg *ptp;
624 stmpconf.tx_type = ptp->tx_tstamp_en ? HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF;
626 stmpconf.rx_filter = ptp->rx_filter;
627 return copy_to_user(ifr->ifr_data, &stmpconf, sizeof(stmpconf)) ?
631 static int bnxt_map_regs(struct bnxt *bp, u32 *reg_arr, int count, int reg_win)
633 u32 reg_base = *reg_arr & BNXT_GRC_BASE_MASK;
637 for (i = 0; i < count; i++) {
638 if ((reg_arr[i] & BNXT_GRC_BASE_MASK) != reg_base)
641 win_off = BNXT_GRCPF_REG_WINDOW_BASE_OUT + (reg_win - 1) * 4;
642 writel(reg_base, bp->bar0 + win_off);
646 static int bnxt_map_ptp_regs(struct bnxt *bp)
648 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
652 reg_arr = ptp->refclk_regs;
653 if (bp->flags & BNXT_FLAG_CHIP_P5) {
654 rc = bnxt_map_regs(bp, reg_arr, 2, BNXT_PTP_GRC_WIN);
657 for (i = 0; i < 2; i++)
658 ptp->refclk_mapped_regs[i] = BNXT_PTP_GRC_WIN_BASE +
659 (ptp->refclk_regs[i] & BNXT_GRC_OFFSET_MASK);
665 static void bnxt_unmap_ptp_regs(struct bnxt *bp)
667 writel(0, bp->bar0 + BNXT_GRCPF_REG_WINDOW_BASE_OUT +
668 (BNXT_PTP_GRC_WIN - 1) * 4);
671 static u64 bnxt_cc_read(const struct cyclecounter *cc)
673 struct bnxt_ptp_cfg *ptp = container_of(cc, struct bnxt_ptp_cfg, cc);
676 bnxt_refclk_read(ptp->bp, NULL, &ns);
680 static void bnxt_stamp_tx_skb(struct bnxt *bp, struct sk_buff *skb)
682 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
683 struct skb_shared_hwtstamps timestamp;
687 rc = bnxt_hwrm_port_ts_query(bp, PORT_TS_QUERY_REQ_FLAGS_PATH_TX, &ts);
689 memset(×tamp, 0, sizeof(timestamp));
690 spin_lock_bh(&ptp->ptp_lock);
691 ns = timecounter_cyc2time(&ptp->tc, ts);
692 spin_unlock_bh(&ptp->ptp_lock);
693 timestamp.hwtstamp = ns_to_ktime(ns);
694 skb_tstamp_tx(ptp->tx_skb, ×tamp);
696 netdev_err(bp->dev, "TS query for TX timer failed rc = %x\n",
700 dev_kfree_skb_any(ptp->tx_skb);
702 atomic_inc(&ptp->tx_avail);
705 static long bnxt_ptp_ts_aux_work(struct ptp_clock_info *ptp_info)
707 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
709 unsigned long now = jiffies;
710 struct bnxt *bp = ptp->bp;
713 bnxt_stamp_tx_skb(bp, ptp->tx_skb);
715 if (!time_after_eq(now, ptp->next_period))
716 return ptp->next_period - now;
718 bnxt_ptp_get_current_time(bp);
719 ptp->next_period = now + HZ;
720 if (time_after_eq(now, ptp->next_overflow_check)) {
721 spin_lock_bh(&ptp->ptp_lock);
722 timecounter_read(&ptp->tc);
723 spin_unlock_bh(&ptp->ptp_lock);
724 ptp->next_overflow_check = now + BNXT_PHC_OVERFLOW_PERIOD;
729 int bnxt_get_tx_ts_p5(struct bnxt *bp, struct sk_buff *skb)
731 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
734 netdev_err(bp->dev, "deferring skb:one SKB is still outstanding\n");
738 ptp_schedule_worker(ptp->ptp_clock, 0);
742 int bnxt_get_rx_ts_p5(struct bnxt *bp, u64 *ts, u32 pkt_ts)
744 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
750 BNXT_READ_TIME64(ptp, time, ptp->old_time);
751 *ts = (time & BNXT_HI_TIMER_MASK) | pkt_ts;
752 if (pkt_ts < (time & BNXT_LO_TIMER_MASK))
753 *ts += BNXT_LO_TIMER_MASK + 1;
758 static const struct ptp_clock_info bnxt_ptp_caps = {
759 .owner = THIS_MODULE,
760 .name = "bnxt clock",
761 .max_adj = BNXT_MAX_PHC_DRIFT,
767 .adjfine = bnxt_ptp_adjfine,
768 .adjtime = bnxt_ptp_adjtime,
769 .do_aux_work = bnxt_ptp_ts_aux_work,
770 .gettimex64 = bnxt_ptp_gettimex,
771 .settime64 = bnxt_ptp_settime,
772 .enable = bnxt_ptp_enable,
775 static int bnxt_ptp_verify(struct ptp_clock_info *ptp_info, unsigned int pin,
776 enum ptp_pin_function func, unsigned int chan)
778 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg,
780 /* Allow only PPS pin function configuration */
781 if (ptp->pps_info.pins[pin].usage <= BNXT_PPS_PIN_PPS_OUT &&
782 func != PTP_PF_PHYSYNC)
788 static int bnxt_ptp_pps_init(struct bnxt *bp)
790 struct hwrm_func_ptp_pin_qcfg_output *resp;
791 struct hwrm_func_ptp_pin_qcfg_input *req;
792 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
793 struct ptp_clock_info *ptp_info;
794 struct bnxt_pps *pps_info;
798 /* Query current/default PIN CFG */
799 rc = hwrm_req_init(bp, req, HWRM_FUNC_PTP_PIN_QCFG);
803 resp = hwrm_req_hold(bp, req);
804 rc = hwrm_req_send(bp, req);
805 if (rc || !resp->num_pins) {
806 hwrm_req_drop(bp, req);
810 ptp_info = &ptp->ptp_info;
811 pps_info = &ptp->pps_info;
812 pps_info->num_pins = resp->num_pins;
813 ptp_info->n_pins = pps_info->num_pins;
814 ptp_info->pin_config = kcalloc(ptp_info->n_pins,
815 sizeof(*ptp_info->pin_config),
817 if (!ptp_info->pin_config) {
818 hwrm_req_drop(bp, req);
822 /* Report the TSIO capability to kernel */
823 pin_usg = &resp->pin0_usage;
824 for (i = 0; i < pps_info->num_pins; i++, pin_usg++) {
825 snprintf(ptp_info->pin_config[i].name,
826 sizeof(ptp_info->pin_config[i].name), "bnxt_pps%d", i);
827 ptp_info->pin_config[i].index = i;
828 ptp_info->pin_config[i].chan = i;
829 if (*pin_usg == BNXT_PPS_PIN_PPS_IN)
830 ptp_info->pin_config[i].func = PTP_PF_EXTTS;
831 else if (*pin_usg == BNXT_PPS_PIN_PPS_OUT)
832 ptp_info->pin_config[i].func = PTP_PF_PEROUT;
834 ptp_info->pin_config[i].func = PTP_PF_NONE;
836 pps_info->pins[i].usage = *pin_usg;
838 hwrm_req_drop(bp, req);
840 /* Only 1 each of ext_ts and per_out pins is available in HW */
841 ptp_info->n_ext_ts = 1;
842 ptp_info->n_per_out = 1;
844 ptp_info->verify = bnxt_ptp_verify;
849 static bool bnxt_pps_config_ok(struct bnxt *bp)
851 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
853 return !(bp->fw_cap & BNXT_FW_CAP_PTP_PPS) == !ptp->ptp_info.pin_config;
856 static void bnxt_ptp_timecounter_init(struct bnxt *bp, bool init_tc)
858 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
860 if (!ptp->ptp_clock) {
861 memset(&ptp->cc, 0, sizeof(ptp->cc));
862 ptp->cc.read = bnxt_cc_read;
863 ptp->cc.mask = CYCLECOUNTER_MASK(48);
865 /* Use timecounter based non-real time mode */
866 ptp->cc.shift = BNXT_CYCLES_SHIFT;
867 ptp->cc.mult = clocksource_khz2mult(BNXT_DEVCLK_FREQ, ptp->cc.shift);
868 ptp->cmult = ptp->cc.mult;
873 ptp->next_overflow_check = jiffies + BNXT_PHC_OVERFLOW_PERIOD;
876 timecounter_init(&ptp->tc, &ptp->cc, ktime_to_ns(ktime_get_real()));
879 /* Caller holds ptp_lock */
880 void bnxt_ptp_rtc_timecounter_init(struct bnxt_ptp_cfg *ptp, u64 ns)
882 timecounter_init(&ptp->tc, &ptp->cc, ns);
883 /* For RTC, cycle_last must be in sync with the timecounter value. */
884 ptp->tc.cycle_last = ns & ptp->cc.mask;
887 int bnxt_ptp_init_rtc(struct bnxt *bp, bool phc_cfg)
889 struct timespec64 tsp;
893 if (!bp->ptp_cfg || !BNXT_PTP_USE_RTC(bp))
897 ktime_get_real_ts64(&tsp);
898 ns = timespec64_to_ns(&tsp);
899 rc = bnxt_ptp_cfg_settime(bp, ns);
903 rc = bnxt_hwrm_port_ts_query(bp, PORT_TS_QUERY_REQ_FLAGS_CURRENT_TIME, &ns);
907 spin_lock_bh(&bp->ptp_cfg->ptp_lock);
908 bnxt_ptp_rtc_timecounter_init(bp->ptp_cfg, ns);
909 spin_unlock_bh(&bp->ptp_cfg->ptp_lock);
914 static void bnxt_ptp_free(struct bnxt *bp)
916 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
918 if (ptp->ptp_clock) {
919 ptp_clock_unregister(ptp->ptp_clock);
920 ptp->ptp_clock = NULL;
921 kfree(ptp->ptp_info.pin_config);
922 ptp->ptp_info.pin_config = NULL;
926 int bnxt_ptp_init(struct bnxt *bp, bool phc_cfg)
928 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
934 rc = bnxt_map_ptp_regs(bp);
938 if (ptp->ptp_clock && bnxt_pps_config_ok(bp))
943 atomic_set(&ptp->tx_avail, BNXT_MAX_TX_TS);
944 spin_lock_init(&ptp->ptp_lock);
946 if (BNXT_PTP_USE_RTC(bp)) {
947 bnxt_ptp_timecounter_init(bp, false);
948 rc = bnxt_ptp_init_rtc(bp, phc_cfg);
952 bnxt_ptp_timecounter_init(bp, true);
953 bnxt_ptp_adjfine_rtc(bp, 0);
955 bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true);
957 ptp->ptp_info = bnxt_ptp_caps;
958 if ((bp->fw_cap & BNXT_FW_CAP_PTP_PPS)) {
959 if (bnxt_ptp_pps_init(bp))
960 netdev_err(bp->dev, "1pps not initialized, continuing without 1pps support\n");
962 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_info, &bp->pdev->dev);
963 if (IS_ERR(ptp->ptp_clock)) {
964 int err = PTR_ERR(ptp->ptp_clock);
966 ptp->ptp_clock = NULL;
970 if (bp->flags & BNXT_FLAG_CHIP_P5) {
971 spin_lock_bh(&ptp->ptp_lock);
972 bnxt_refclk_read(bp, NULL, &ptp->current_time);
973 WRITE_ONCE(ptp->old_time, ptp->current_time);
974 spin_unlock_bh(&ptp->ptp_lock);
975 ptp_schedule_worker(ptp->ptp_clock, 0);
981 bnxt_unmap_ptp_regs(bp);
985 void bnxt_ptp_clear(struct bnxt *bp)
987 struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
993 ptp_clock_unregister(ptp->ptp_clock);
995 ptp->ptp_clock = NULL;
996 kfree(ptp->ptp_info.pin_config);
997 ptp->ptp_info.pin_config = NULL;
1000 dev_kfree_skb_any(ptp->tx_skb);
1003 bnxt_unmap_ptp_regs(bp);