1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
2 /* Google virtual Ethernet (gve) driver
3 *
4 * Copyright (C) 2025 Google LLC
5 */
6
7 #include "gve.h"
8 #include "gve_adminq.h"
9
10 /* Interval to schedule a nic timestamp calibration, 250ms. */
11 #define GVE_NIC_TS_SYNC_INTERVAL_MS 250
12
13 /* Read the nic timestamp from hardware via the admin queue. */
gve_clock_nic_ts_read(struct gve_priv * priv)14 int gve_clock_nic_ts_read(struct gve_priv *priv)
15 {
16 u64 nic_raw;
17 int err;
18
19 err = gve_adminq_report_nic_ts(priv, priv->nic_ts_report_bus);
20 if (err)
21 return err;
22
23 nic_raw = be64_to_cpu(priv->nic_ts_report->nic_timestamp);
24 WRITE_ONCE(priv->last_sync_nic_counter, nic_raw);
25
26 return 0;
27 }
28
gve_ptp_gettimex64(struct ptp_clock_info * info,struct timespec64 * ts,struct ptp_system_timestamp * sts)29 static int gve_ptp_gettimex64(struct ptp_clock_info *info,
30 struct timespec64 *ts,
31 struct ptp_system_timestamp *sts)
32 {
33 return -EOPNOTSUPP;
34 }
35
gve_ptp_settime64(struct ptp_clock_info * info,const struct timespec64 * ts)36 static int gve_ptp_settime64(struct ptp_clock_info *info,
37 const struct timespec64 *ts)
38 {
39 return -EOPNOTSUPP;
40 }
41
gve_ptp_do_aux_work(struct ptp_clock_info * info)42 static long gve_ptp_do_aux_work(struct ptp_clock_info *info)
43 {
44 const struct gve_ptp *ptp = container_of(info, struct gve_ptp, info);
45 struct gve_priv *priv = ptp->priv;
46 int err;
47
48 if (gve_get_reset_in_progress(priv) || !gve_get_admin_queue_ok(priv))
49 goto out;
50
51 err = gve_clock_nic_ts_read(priv);
52 if (err && net_ratelimit())
53 dev_err(&priv->pdev->dev,
54 "%s read err %d\n", __func__, err);
55
56 out:
57 return msecs_to_jiffies(GVE_NIC_TS_SYNC_INTERVAL_MS);
58 }
59
60 static const struct ptp_clock_info gve_ptp_caps = {
61 .owner = THIS_MODULE,
62 .name = "gve clock",
63 .gettimex64 = gve_ptp_gettimex64,
64 .settime64 = gve_ptp_settime64,
65 .do_aux_work = gve_ptp_do_aux_work,
66 };
67
gve_ptp_init(struct gve_priv * priv)68 static int gve_ptp_init(struct gve_priv *priv)
69 {
70 struct gve_ptp *ptp;
71 int err;
72
73 if (!priv->nic_timestamp_supported) {
74 dev_dbg(&priv->pdev->dev, "Device does not support PTP\n");
75 return -EOPNOTSUPP;
76 }
77
78 priv->ptp = kzalloc(sizeof(*priv->ptp), GFP_KERNEL);
79 if (!priv->ptp)
80 return -ENOMEM;
81
82 ptp = priv->ptp;
83 ptp->info = gve_ptp_caps;
84 ptp->clock = ptp_clock_register(&ptp->info, &priv->pdev->dev);
85
86 if (IS_ERR(ptp->clock)) {
87 dev_err(&priv->pdev->dev, "PTP clock registration failed\n");
88 err = PTR_ERR(ptp->clock);
89 goto free_ptp;
90 }
91
92 ptp->priv = priv;
93 return 0;
94
95 free_ptp:
96 kfree(ptp);
97 priv->ptp = NULL;
98 return err;
99 }
100
gve_ptp_release(struct gve_priv * priv)101 static void gve_ptp_release(struct gve_priv *priv)
102 {
103 struct gve_ptp *ptp = priv->ptp;
104
105 if (!ptp)
106 return;
107
108 if (ptp->clock)
109 ptp_clock_unregister(ptp->clock);
110
111 kfree(ptp);
112 priv->ptp = NULL;
113 }
114
gve_init_clock(struct gve_priv * priv)115 int gve_init_clock(struct gve_priv *priv)
116 {
117 int err;
118
119 if (!priv->nic_timestamp_supported)
120 return 0;
121
122 err = gve_ptp_init(priv);
123 if (err)
124 return err;
125
126 priv->nic_ts_report =
127 dma_alloc_coherent(&priv->pdev->dev,
128 sizeof(struct gve_nic_ts_report),
129 &priv->nic_ts_report_bus,
130 GFP_KERNEL);
131 if (!priv->nic_ts_report) {
132 dev_err(&priv->pdev->dev, "%s dma alloc error\n", __func__);
133 err = -ENOMEM;
134 goto release_ptp;
135 }
136
137 return 0;
138
139 release_ptp:
140 gve_ptp_release(priv);
141 return err;
142 }
143
gve_teardown_clock(struct gve_priv * priv)144 void gve_teardown_clock(struct gve_priv *priv)
145 {
146 gve_ptp_release(priv);
147
148 if (priv->nic_ts_report) {
149 dma_free_coherent(&priv->pdev->dev,
150 sizeof(struct gve_nic_ts_report),
151 priv->nic_ts_report, priv->nic_ts_report_bus);
152 priv->nic_ts_report = NULL;
153 }
154 }
155