1/* PTP 1588 clock using the Renesas Ethernet AVB
  2 *
  3 * Copyright (C) 2013-2015 Renesas Electronics Corporation
  4 * Copyright (C) 2015 Renesas Solutions Corp.
  5 * Copyright (C) 2015-2016 Cogent Embedded, Inc. <source@cogentembedded.com>
  6 *
  7 *  This program is free software; you can redistribute it and/or modify
  8 *  it under the terms of the GNU General Public License as published by
  9 *  the Free Software Foundation; either version 2 of the License, or
 10 *  (at your option) any later version.
 11 */
 12
 13#include "ravb.h"
 14
 15static int ravb_ptp_tcr_request(struct ravb_private *priv, u32 request)
 16{
 17	struct net_device *ndev = priv->ndev;
 18	int error;
 19
 20	error = ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
 21	if (error)
 22		return error;
 23
 24	ravb_modify(ndev, GCCR, request, request);
 25	return ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
 26}
 27
 28/* Caller must hold the lock */
 29static int ravb_ptp_time_read(struct ravb_private *priv, struct timespec64 *ts)
 30{
 31	struct net_device *ndev = priv->ndev;
 32	int error;
 33
 34	error = ravb_ptp_tcr_request(priv, GCCR_TCR_CAPTURE);
 35	if (error)
 36		return error;
 37
 38	ts->tv_nsec = ravb_read(ndev, GCT0);
 39	ts->tv_sec  = ravb_read(ndev, GCT1) |
 40		((s64)ravb_read(ndev, GCT2) << 32);
 41
 42	return 0;
 43}
 44
 45/* Caller must hold the lock */
 46static int ravb_ptp_time_write(struct ravb_private *priv,
 47				const struct timespec64 *ts)
 48{
 49	struct net_device *ndev = priv->ndev;
 50	int error;
 51	u32 gccr;
 52
 53	error = ravb_ptp_tcr_request(priv, GCCR_TCR_RESET);
 54	if (error)
 55		return error;
 56
 57	gccr = ravb_read(ndev, GCCR);
 58	if (gccr & GCCR_LTO)
 59		return -EBUSY;
 60	ravb_write(ndev, ts->tv_nsec, GTO0);
 61	ravb_write(ndev, ts->tv_sec,  GTO1);
 62	ravb_write(ndev, (ts->tv_sec >> 32) & 0xffff, GTO2);
 63	ravb_write(ndev, gccr | GCCR_LTO, GCCR);
 64
 65	return 0;
 66}
 67
 68/* Caller must hold the lock */
 69static int ravb_ptp_update_compare(struct ravb_private *priv, u32 ns)
 70{
 71	struct net_device *ndev = priv->ndev;
 72	/* When the comparison value (GPTC.PTCV) is in range of
 73	 * [x-1 to x+1] (x is the configured increment value in
 74	 * GTI.TIV), it may happen that a comparison match is
 75	 * not detected when the timer wraps around.
 76	 */
 77	u32 gti_ns_plus_1 = (priv->ptp.current_addend >> 20) + 1;
 78	u32 gccr;
 79
 80	if (ns < gti_ns_plus_1)
 81		ns = gti_ns_plus_1;
 82	else if (ns > 0 - gti_ns_plus_1)
 83		ns = 0 - gti_ns_plus_1;
 84
 85	gccr = ravb_read(ndev, GCCR);
 86	if (gccr & GCCR_LPTC)
 87		return -EBUSY;
 88	ravb_write(ndev, ns, GPTC);
 89	ravb_write(ndev, gccr | GCCR_LPTC, GCCR);
 90
 91	return 0;
 92}
 93
 94/* PTP clock operations */
 95static int ravb_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
 96{
 97	struct ravb_private *priv = container_of(ptp, struct ravb_private,
 98						 ptp.info);
 99	struct net_device *ndev = priv->ndev;
100	unsigned long flags;
101	u32 diff, addend;
102	bool neg_adj = false;
103	u32 gccr;
104
105	if (ppb < 0) {
106		neg_adj = true;
107		ppb = -ppb;
108	}
109	addend = priv->ptp.default_addend;
110	diff = div_u64((u64)addend * ppb, NSEC_PER_SEC);
111
112	addend = neg_adj ? addend - diff : addend + diff;
113
114	spin_lock_irqsave(&priv->lock, flags);
115
116	priv->ptp.current_addend = addend;
117
118	gccr = ravb_read(ndev, GCCR);
119	if (gccr & GCCR_LTI) {
120		spin_unlock_irqrestore(&priv->lock, flags);
121		return -EBUSY;
122	}
123	ravb_write(ndev, addend & GTI_TIV, GTI);
124	ravb_write(ndev, gccr | GCCR_LTI, GCCR);
125
126	spin_unlock_irqrestore(&priv->lock, flags);
127
128	return 0;
129}
130
131static int ravb_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
132{
133	struct ravb_private *priv = container_of(ptp, struct ravb_private,
134						 ptp.info);
135	struct timespec64 ts;
136	unsigned long flags;
137	int error;
138
139	spin_lock_irqsave(&priv->lock, flags);
140	error = ravb_ptp_time_read(priv, &ts);
141	if (!error) {
142		u64 now = ktime_to_ns(timespec64_to_ktime(ts));
143
144		ts = ns_to_timespec64(now + delta);
145		error = ravb_ptp_time_write(priv, &ts);
146	}
147	spin_unlock_irqrestore(&priv->lock, flags);
148
149	return error;
150}
151
152static int ravb_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts)
153{
154	struct ravb_private *priv = container_of(ptp, struct ravb_private,
155						 ptp.info);
156	unsigned long flags;
157	int error;
158
159	spin_lock_irqsave(&priv->lock, flags);
160	error = ravb_ptp_time_read(priv, ts);
161	spin_unlock_irqrestore(&priv->lock, flags);
162
163	return error;
164}
165
166static int ravb_ptp_settime64(struct ptp_clock_info *ptp,
167			      const struct timespec64 *ts)
168{
169	struct ravb_private *priv = container_of(ptp, struct ravb_private,
170						 ptp.info);
171	unsigned long flags;
172	int error;
173
174	spin_lock_irqsave(&priv->lock, flags);
175	error = ravb_ptp_time_write(priv, ts);
176	spin_unlock_irqrestore(&priv->lock, flags);
177
178	return error;
179}
180
181static int ravb_ptp_extts(struct ptp_clock_info *ptp,
182			  struct ptp_extts_request *req, int on)
183{
184	struct ravb_private *priv = container_of(ptp, struct ravb_private,
185						 ptp.info);
186	struct net_device *ndev = priv->ndev;
187	unsigned long flags;
188
189	if (req->index)
190		return -EINVAL;
191
192	if (priv->ptp.extts[req->index] == on)
193		return 0;
194	priv->ptp.extts[req->index] = on;
195
196	spin_lock_irqsave(&priv->lock, flags);
197	if (priv->chip_id == RCAR_GEN2)
198		ravb_modify(ndev, GIC, GIC_PTCE, on ? GIC_PTCE : 0);
199	else if (on)
200		ravb_write(ndev, GIE_PTCS, GIE);
201	else
202		ravb_write(ndev, GID_PTCD, GID);
203	mmiowb();
204	spin_unlock_irqrestore(&priv->lock, flags);
205
206	return 0;
207}
208
209static int ravb_ptp_perout(struct ptp_clock_info *ptp,
210			   struct ptp_perout_request *req, int on)
211{
212	struct ravb_private *priv = container_of(ptp, struct ravb_private,
213						 ptp.info);
214	struct net_device *ndev = priv->ndev;
215	struct ravb_ptp_perout *perout;
216	unsigned long flags;
217	int error = 0;
218
219	if (req->index)
220		return -EINVAL;
221
222	if (on) {
223		u64 start_ns;
224		u64 period_ns;
225
226		start_ns = req->start.sec * NSEC_PER_SEC + req->start.nsec;
227		period_ns = req->period.sec * NSEC_PER_SEC + req->period.nsec;
228
229		if (start_ns > U32_MAX) {
230			netdev_warn(ndev,
231				    "ptp: start value (nsec) is over limit. Maximum size of start is only 32 bits\n");
232			return -ERANGE;
233		}
234
235		if (period_ns > U32_MAX) {
236			netdev_warn(ndev,
237				    "ptp: period value (nsec) is over limit. Maximum size of period is only 32 bits\n");
238			return -ERANGE;
239		}
240
241		spin_lock_irqsave(&priv->lock, flags);
242
243		perout = &priv->ptp.perout[req->index];
244		perout->target = (u32)start_ns;
245		perout->period = (u32)period_ns;
246		error = ravb_ptp_update_compare(priv, (u32)start_ns);
247		if (!error) {
248			/* Unmask interrupt */
249			if (priv->chip_id == RCAR_GEN2)
250				ravb_modify(ndev, GIC, GIC_PTME, GIC_PTME);
251			else
252				ravb_write(ndev, GIE_PTMS0, GIE);
253		}
254	} else	{
255		spin_lock_irqsave(&priv->lock, flags);
256
257		perout = &priv->ptp.perout[req->index];
258		perout->period = 0;
259
260		/* Mask interrupt */
261		if (priv->chip_id == RCAR_GEN2)
262			ravb_modify(ndev, GIC, GIC_PTME, 0);
263		else
264			ravb_write(ndev, GID_PTMD0, GID);
265	}
266	mmiowb();
267	spin_unlock_irqrestore(&priv->lock, flags);
268
269	return error;
270}
271
272static int ravb_ptp_enable(struct ptp_clock_info *ptp,
273			   struct ptp_clock_request *req, int on)
274{
275	switch (req->type) {
276	case PTP_CLK_REQ_EXTTS:
277		return ravb_ptp_extts(ptp, &req->extts, on);
278	case PTP_CLK_REQ_PEROUT:
279		return ravb_ptp_perout(ptp, &req->perout, on);
280	default:
281		return -EOPNOTSUPP;
282	}
283}
284
285static const struct ptp_clock_info ravb_ptp_info = {
286	.owner		= THIS_MODULE,
287	.name		= "ravb clock",
288	.max_adj	= 50000000,
289	.n_ext_ts	= N_EXT_TS,
290	.n_per_out	= N_PER_OUT,
291	.adjfreq	= ravb_ptp_adjfreq,
292	.adjtime	= ravb_ptp_adjtime,
293	.gettime64	= ravb_ptp_gettime64,
294	.settime64	= ravb_ptp_settime64,
295	.enable		= ravb_ptp_enable,
296};
297
298/* Caller must hold the lock */
299void ravb_ptp_interrupt(struct net_device *ndev)
300{
301	struct ravb_private *priv = netdev_priv(ndev);
302	u32 gis = ravb_read(ndev, GIS);
303
304	gis &= ravb_read(ndev, GIC);
305	if (gis & GIS_PTCF) {
306		struct ptp_clock_event event;
307
308		event.type = PTP_CLOCK_EXTTS;
309		event.index = 0;
310		event.timestamp = ravb_read(ndev, GCPT);
311		ptp_clock_event(priv->ptp.clock, &event);
312	}
313	if (gis & GIS_PTMF) {
314		struct ravb_ptp_perout *perout = priv->ptp.perout;
315
316		if (perout->period) {
317			perout->target += perout->period;
318			ravb_ptp_update_compare(priv, perout->target);
319		}
320	}
321
322	ravb_write(ndev, ~gis, GIS);
323}
324
325void ravb_ptp_init(struct net_device *ndev, struct platform_device *pdev)
326{
327	struct ravb_private *priv = netdev_priv(ndev);
328	unsigned long flags;
329
330	priv->ptp.info = ravb_ptp_info;
331
332	priv->ptp.default_addend = ravb_read(ndev, GTI);
333	priv->ptp.current_addend = priv->ptp.default_addend;
334
335	spin_lock_irqsave(&priv->lock, flags);
336	ravb_wait(ndev, GCCR, GCCR_TCR, GCCR_TCR_NOREQ);
337	ravb_modify(ndev, GCCR, GCCR_TCSS, GCCR_TCSS_ADJGPTP);
338	mmiowb();
339	spin_unlock_irqrestore(&priv->lock, flags);
340
341	priv->ptp.clock = ptp_clock_register(&priv->ptp.info, &pdev->dev);
342}
343
344void ravb_ptp_stop(struct net_device *ndev)
345{
346	struct ravb_private *priv = netdev_priv(ndev);
347
348	ravb_write(ndev, 0, GIC);
349	ravb_write(ndev, 0, GIS);
350
351	ptp_clock_unregister(priv->ptp.clock);
352}