1 // SPDX-License-Identifier: GPL-2.0+
2 /* PTP 1588 clock using the Renesas Ethernet AVB
4 * Copyright (C) 2013-2015 Renesas Electronics Corporation
5 * Copyright (C) 2015 Renesas Solutions Corp.
6 * Copyright (C) 2015-2016 Cogent Embedded, Inc. <source@cogentembedded.com>
11 static int ravb_ptp_tcr_request(struct ravb_private *priv, u32 request)
13 struct net_device *ndev = priv->ndev;
16 error = ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
20 ravb_modify(ndev, GCCR, request, request);
21 return ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
24 /* Caller must hold the lock */
25 static int ravb_ptp_time_read(struct ravb_private *priv, struct timespec64 *ts)
27 struct net_device *ndev = priv->ndev;
30 error = ravb_ptp_tcr_request(priv, GCCR_TCR_CAPTURE);
34 ts->tv_nsec = ravb_read(ndev, GCT0);
35 ts->tv_sec = ravb_read(ndev, GCT1) |
36 ((s64)ravb_read(ndev, GCT2) << 32);
41 /* Caller must hold the lock */
42 static int ravb_ptp_time_write(struct ravb_private *priv,
43 const struct timespec64 *ts)
45 struct net_device *ndev = priv->ndev;
49 error = ravb_ptp_tcr_request(priv, GCCR_TCR_RESET);
53 gccr = ravb_read(ndev, GCCR);
56 ravb_write(ndev, ts->tv_nsec, GTO0);
57 ravb_write(ndev, ts->tv_sec, GTO1);
58 ravb_write(ndev, (ts->tv_sec >> 32) & 0xffff, GTO2);
59 ravb_write(ndev, gccr | GCCR_LTO, GCCR);
64 /* Caller must hold the lock */
65 static int ravb_ptp_update_compare(struct ravb_private *priv, u32 ns)
67 struct net_device *ndev = priv->ndev;
68 /* When the comparison value (GPTC.PTCV) is in range of
69 * [x-1 to x+1] (x is the configured increment value in
70 * GTI.TIV), it may happen that a comparison match is
71 * not detected when the timer wraps around.
73 u32 gti_ns_plus_1 = (priv->ptp.current_addend >> 20) + 1;
76 if (ns < gti_ns_plus_1)
78 else if (ns > 0 - gti_ns_plus_1)
79 ns = 0 - gti_ns_plus_1;
81 gccr = ravb_read(ndev, GCCR);
84 ravb_write(ndev, ns, GPTC);
85 ravb_write(ndev, gccr | GCCR_LPTC, GCCR);
90 /* PTP clock operations */
91 static int ravb_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
93 struct ravb_private *priv = container_of(ptp, struct ravb_private,
95 struct net_device *ndev = priv->ndev;
105 addend = priv->ptp.default_addend;
106 diff = div_u64((u64)addend * ppb, NSEC_PER_SEC);
108 addend = neg_adj ? addend - diff : addend + diff;
110 spin_lock_irqsave(&priv->lock, flags);
112 priv->ptp.current_addend = addend;
114 gccr = ravb_read(ndev, GCCR);
115 if (gccr & GCCR_LTI) {
116 spin_unlock_irqrestore(&priv->lock, flags);
119 ravb_write(ndev, addend & GTI_TIV, GTI);
120 ravb_write(ndev, gccr | GCCR_LTI, GCCR);
122 spin_unlock_irqrestore(&priv->lock, flags);
127 static int ravb_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
129 struct ravb_private *priv = container_of(ptp, struct ravb_private,
131 struct timespec64 ts;
135 spin_lock_irqsave(&priv->lock, flags);
136 error = ravb_ptp_time_read(priv, &ts);
138 u64 now = ktime_to_ns(timespec64_to_ktime(ts));
140 ts = ns_to_timespec64(now + delta);
141 error = ravb_ptp_time_write(priv, &ts);
143 spin_unlock_irqrestore(&priv->lock, flags);
148 static int ravb_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts)
150 struct ravb_private *priv = container_of(ptp, struct ravb_private,
155 spin_lock_irqsave(&priv->lock, flags);
156 error = ravb_ptp_time_read(priv, ts);
157 spin_unlock_irqrestore(&priv->lock, flags);
162 static int ravb_ptp_settime64(struct ptp_clock_info *ptp,
163 const struct timespec64 *ts)
165 struct ravb_private *priv = container_of(ptp, struct ravb_private,
170 spin_lock_irqsave(&priv->lock, flags);
171 error = ravb_ptp_time_write(priv, ts);
172 spin_unlock_irqrestore(&priv->lock, flags);
177 static int ravb_ptp_extts(struct ptp_clock_info *ptp,
178 struct ptp_extts_request *req, int on)
180 struct ravb_private *priv = container_of(ptp, struct ravb_private,
182 struct net_device *ndev = priv->ndev;
188 if (priv->ptp.extts[req->index] == on)
190 priv->ptp.extts[req->index] = on;
192 spin_lock_irqsave(&priv->lock, flags);
193 if (priv->chip_id == RCAR_GEN2)
194 ravb_modify(ndev, GIC, GIC_PTCE, on ? GIC_PTCE : 0);
196 ravb_write(ndev, GIE_PTCS, GIE);
198 ravb_write(ndev, GID_PTCD, GID);
199 spin_unlock_irqrestore(&priv->lock, flags);
204 static int ravb_ptp_perout(struct ptp_clock_info *ptp,
205 struct ptp_perout_request *req, int on)
207 struct ravb_private *priv = container_of(ptp, struct ravb_private,
209 struct net_device *ndev = priv->ndev;
210 struct ravb_ptp_perout *perout;
214 /* Reject requests with unsupported flags */
225 start_ns = req->start.sec * NSEC_PER_SEC + req->start.nsec;
226 period_ns = req->period.sec * NSEC_PER_SEC + req->period.nsec;
228 if (start_ns > U32_MAX) {
230 "ptp: start value (nsec) is over limit. Maximum size of start is only 32 bits\n");
234 if (period_ns > U32_MAX) {
236 "ptp: period value (nsec) is over limit. Maximum size of period is only 32 bits\n");
240 spin_lock_irqsave(&priv->lock, flags);
242 perout = &priv->ptp.perout[req->index];
243 perout->target = (u32)start_ns;
244 perout->period = (u32)period_ns;
245 error = ravb_ptp_update_compare(priv, (u32)start_ns);
247 /* Unmask interrupt */
248 if (priv->chip_id == RCAR_GEN2)
249 ravb_modify(ndev, GIC, GIC_PTME, GIC_PTME);
251 ravb_write(ndev, GIE_PTMS0, GIE);
254 spin_lock_irqsave(&priv->lock, flags);
256 perout = &priv->ptp.perout[req->index];
260 if (priv->chip_id == RCAR_GEN2)
261 ravb_modify(ndev, GIC, GIC_PTME, 0);
263 ravb_write(ndev, GID_PTMD0, GID);
265 spin_unlock_irqrestore(&priv->lock, flags);
270 static int ravb_ptp_enable(struct ptp_clock_info *ptp,
271 struct ptp_clock_request *req, int on)
274 case PTP_CLK_REQ_EXTTS:
275 return ravb_ptp_extts(ptp, &req->extts, on);
276 case PTP_CLK_REQ_PEROUT:
277 return ravb_ptp_perout(ptp, &req->perout, on);
283 static const struct ptp_clock_info ravb_ptp_info = {
284 .owner = THIS_MODULE,
285 .name = "ravb clock",
287 .n_ext_ts = N_EXT_TS,
288 .n_per_out = N_PER_OUT,
289 .adjfreq = ravb_ptp_adjfreq,
290 .adjtime = ravb_ptp_adjtime,
291 .gettime64 = ravb_ptp_gettime64,
292 .settime64 = ravb_ptp_settime64,
293 .enable = ravb_ptp_enable,
296 /* Caller must hold the lock */
297 void ravb_ptp_interrupt(struct net_device *ndev)
299 struct ravb_private *priv = netdev_priv(ndev);
300 u32 gis = ravb_read(ndev, GIS);
302 gis &= ravb_read(ndev, GIC);
303 if (gis & GIS_PTCF) {
304 struct ptp_clock_event event;
306 event.type = PTP_CLOCK_EXTTS;
308 event.timestamp = ravb_read(ndev, GCPT);
309 ptp_clock_event(priv->ptp.clock, &event);
311 if (gis & GIS_PTMF) {
312 struct ravb_ptp_perout *perout = priv->ptp.perout;
314 if (perout->period) {
315 perout->target += perout->period;
316 ravb_ptp_update_compare(priv, perout->target);
320 ravb_write(ndev, ~(gis | GIS_RESERVED), GIS);
323 void ravb_ptp_init(struct net_device *ndev, struct platform_device *pdev)
325 struct ravb_private *priv = netdev_priv(ndev);
328 priv->ptp.info = ravb_ptp_info;
330 priv->ptp.default_addend = ravb_read(ndev, GTI);
331 priv->ptp.current_addend = priv->ptp.default_addend;
333 spin_lock_irqsave(&priv->lock, flags);
334 ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
335 ravb_modify(ndev, GCCR, GCCR_TCSS, GCCR_TCSS_ADJGPTP);
336 spin_unlock_irqrestore(&priv->lock, flags);
338 priv->ptp.clock = ptp_clock_register(&priv->ptp.info, &pdev->dev);
341 void ravb_ptp_stop(struct net_device *ndev)
343 struct ravb_private *priv = netdev_priv(ndev);
345 ravb_write(ndev, 0, GIC);
346 ravb_write(ndev, 0, GIS);
348 ptp_clock_unregister(priv->ptp.clock);