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