gve: Add support to query the nic clock

Query the nic clock and store the results. The timestamp delivered
in descriptors has a wraparound time of ~4 seconds so 250ms is chosen
as the sync cadence to provide a balance between performance, and
drift potential when we do start associating host time and nic time.

Leverage PTP's aux_work to query the nic clock periodically.

Signed-off-by: Kevin Yang <yyd@google.com>
Signed-off-by: John Fraker <jfraker@google.com>
Signed-off-by: Tim Hostetler <thostet@google.com>
Signed-off-by: Ziwei Xiao <ziweixiao@google.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Signed-off-by: Harshitha Ramamurthy <hramamurthy@google.com>
Link: https://patch.msgid.link/20250614000754.164827-6-hramamurthy@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/ethernet/google/gve/gve.h b/drivers/net/ethernet/google/gve/gve.h
index 8d2aa654fd4c4898579826dcd5cc9f3fc074f8da..527e17da60bcf6c47fac5ba37fcd7ad97d4c04d3 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve.h
+++ b/drivers/net/ethernet/google/gve/gve.h
@@ -882,6 +882,9 @@ struct gve_priv {
        /* True if the device supports reading the nic clock */
        bool nic_timestamp_supported;
        struct gve_ptp *ptp;
+       struct gve_nic_ts_report *nic_ts_report;
+       dma_addr_t nic_ts_report_bus;
+       u64 last_sync_nic_counter; /* Clock counter from last NIC TS report */
 };
 
 enum gve_service_task_flags_bit {
@@ -1261,6 +1264,24 @@ int gve_del_flow_rule(struct gve_priv *priv, struct ethtool_rxnfc *cmd);
 int gve_flow_rules_reset(struct gve_priv *priv);
 /* RSS config */
 int gve_init_rss_config(struct gve_priv *priv, u16 num_queues);
+/* PTP and timestamping */
+#if IS_ENABLED(CONFIG_PTP_1588_CLOCK)
+int gve_clock_nic_ts_read(struct gve_priv *priv);
+int gve_init_clock(struct gve_priv *priv);
+void gve_teardown_clock(struct gve_priv *priv);
+#else /* CONFIG_PTP_1588_CLOCK */
+static inline int gve_clock_nic_ts_read(struct gve_priv *priv)
+{
+       return -EOPNOTSUPP;
+}
+
+static inline int gve_init_clock(struct gve_priv *priv)
+{
+       return 0;
+}
+
+static inline void gve_teardown_clock(struct gve_priv *priv) { }
+#endif /* CONFIG_PTP_1588_CLOCK */
 /* report stats handling */
 void gve_handle_report_stats(struct gve_priv *priv);
 /* exported by ethtool.c */

diff --git a/drivers/net/ethernet/google/gve/gve_main.c b/drivers/net/ethernet/google/gve/gve_main.c
index dc35a23ec47fdd06d0e39378de98142ea5d7db03..bc2f36962ee8d6a9dd9254523583b395a437f2a9 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve_main.c
+++ b/drivers/net/ethernet/google/gve/gve_main.c
@@ -619,9 +619,12 @@ static int gve_setup_device_resources(struct gve_priv *priv)
        err = gve_alloc_counter_array(priv);
        if (err)
                goto abort_with_rss_config_cache;
-       err = gve_alloc_notify_blocks(priv);
+       err = gve_init_clock(priv);
        if (err)
                goto abort_with_counter;
+       err = gve_alloc_notify_blocks(priv);
+       if (err)
+               goto abort_with_clock;
        err = gve_alloc_stats_report(priv);
        if (err)
                goto abort_with_ntfy_blocks;
@@ -674,6 +677,8 @@ abort_with_stats_report:
        gve_free_stats_report(priv);
 abort_with_ntfy_blocks:
        gve_free_notify_blocks(priv);
+abort_with_clock:
+       gve_teardown_clock(priv);
 abort_with_counter:
        gve_free_counter_array(priv);
 abort_with_rss_config_cache:

diff --git a/drivers/net/ethernet/google/gve/gve_ptp.c b/drivers/net/ethernet/google/gve/gve_ptp.c
index 293f8dd49afe945d6cba9fd32ce16f879299e0c8..e96247c9d68d290f3d5c333b284d6a09bdbacedb 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve_ptp.c
+++ b/drivers/net/ethernet/google/gve/gve_ptp.c
@@ -5,13 +5,52 @@
  */
 
 #include "gve.h"
+#include "gve_adminq.h"
+
+/* Interval to schedule a nic timestamp calibration, 250ms. */
+#define GVE_NIC_TS_SYNC_INTERVAL_MS 250
+
+/* Read the nic timestamp from hardware via the admin queue. */
+int gve_clock_nic_ts_read(struct gve_priv *priv)
+{
+       u64 nic_raw;
+       int err;
+
+       err = gve_adminq_report_nic_ts(priv, priv->nic_ts_report_bus);
+       if (err)
+               return err;
+
+       nic_raw = be64_to_cpu(priv->nic_ts_report->nic_timestamp);
+       WRITE_ONCE(priv->last_sync_nic_counter, nic_raw);
+
+       return 0;
+}
+
+static long gve_ptp_do_aux_work(struct ptp_clock_info *info)
+{
+       const struct gve_ptp *ptp = container_of(info, struct gve_ptp, info);
+       struct gve_priv *priv = ptp->priv;
+       int err;
+
+       if (gve_get_reset_in_progress(priv) || !gve_get_admin_queue_ok(priv))
+               goto out;
+
+       err = gve_clock_nic_ts_read(priv);
+       if (err && net_ratelimit())
+               dev_err(&priv->pdev->dev,
+                       "%s read err %d\n", __func__, err);
+
+out:
+       return msecs_to_jiffies(GVE_NIC_TS_SYNC_INTERVAL_MS);
+}
 
 static const struct ptp_clock_info gve_ptp_caps = {
        .owner          = THIS_MODULE,
        .name           = "gve clock",
+       .do_aux_work    = gve_ptp_do_aux_work,
 };
 
-static int __maybe_unused gve_ptp_init(struct gve_priv *priv)
+static int gve_ptp_init(struct gve_priv *priv)
 {
        struct gve_ptp *ptp;
        int err;
@@ -44,7 +83,7 @@ free_ptp:
        return err;
 }
 
-static void __maybe_unused gve_ptp_release(struct gve_priv *priv)
+static void gve_ptp_release(struct gve_priv *priv)
 {
        struct gve_ptp *ptp = priv->ptp;
 
@@ -57,3 +96,44 @@ static void __maybe_unused gve_ptp_release(struct gve_priv *priv)
        kfree(ptp);
        priv->ptp = NULL;
 }
+
+int gve_init_clock(struct gve_priv *priv)
+{
+       int err;
+
+       if (!priv->nic_timestamp_supported)
+               return 0;
+
+       err = gve_ptp_init(priv);
+       if (err)
+               return err;
+
+       priv->nic_ts_report =
+               dma_alloc_coherent(&priv->pdev->dev,
+                                  sizeof(struct gve_nic_ts_report),
+                                  &priv->nic_ts_report_bus,
+                                  GFP_KERNEL);
+       if (!priv->nic_ts_report) {
+               dev_err(&priv->pdev->dev, "%s dma alloc error\n", __func__);
+               err = -ENOMEM;
+               goto release_ptp;
+       }
+
+       return 0;
+
+release_ptp:
+       gve_ptp_release(priv);
+       return err;
+}
+
+void gve_teardown_clock(struct gve_priv *priv)
+{
+       gve_ptp_release(priv);
+
+       if (priv->nic_ts_report) {
+               dma_free_coherent(&priv->pdev->dev,
+                                 sizeof(struct gve_nic_ts_report),
+                                 priv->nic_ts_report, priv->nic_ts_report_bus);
+               priv->nic_ts_report = NULL;
+       }
+}