This source file includes following definitions.
- sja1105_get_ts_info
- sja1105et_ptp_cmd
- sja1105pqrs_ptp_cmd
- sja1105_tstamp_reconstruct
- sja1105_ptpegr_ts_poll
- sja1105_ptp_reset
- sja1105_ptp_gettime
- sja1105_ptp_settime
- sja1105_ptp_adjfine
- sja1105_ptp_adjtime
- sja1105_ptptsclk_read
- sja1105_ptp_overflow_check
- sja1105_ptp_clock_register
- sja1105_ptp_clock_unregister
1
2
3
4 #include "sja1105.h"
5
6
7
8
9
10
11
12
13 #define SJA1105_MAX_ADJ_PPB 32000000
14 #define SJA1105_SIZE_PTP_CMD 4
15
16
17
18
19
20
21
22
23 #define SJA1105_CC_SHIFT 28
24 #define SJA1105_CC_MULT (8 << SJA1105_CC_SHIFT)
25
26
27
28
29
30
31
32 #define SJA1105_REFRESH_INTERVAL (HZ * 60)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 #define SJA1105_CC_MULT_NUM (1 << 9)
51 #define SJA1105_CC_MULT_DEM 15625
52
53 #define ptp_to_sja1105(d) container_of((d), struct sja1105_private, ptp_caps)
54 #define cc_to_sja1105(d) container_of((d), struct sja1105_private, tstamp_cc)
55 #define dw_to_sja1105(d) container_of((d), struct sja1105_private, refresh_work)
56
57 struct sja1105_ptp_cmd {
58 u64 resptp;
59 };
60
61 int sja1105_get_ts_info(struct dsa_switch *ds, int port,
62 struct ethtool_ts_info *info)
63 {
64 struct sja1105_private *priv = ds->priv;
65
66
67 if (!priv->clock)
68 return -ENODEV;
69
70 info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
71 SOF_TIMESTAMPING_RX_HARDWARE |
72 SOF_TIMESTAMPING_RAW_HARDWARE;
73 info->tx_types = (1 << HWTSTAMP_TX_OFF) |
74 (1 << HWTSTAMP_TX_ON);
75 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
76 (1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT);
77 info->phc_index = ptp_clock_index(priv->clock);
78 return 0;
79 }
80
81 int sja1105et_ptp_cmd(const void *ctx, const void *data)
82 {
83 const struct sja1105_ptp_cmd *cmd = data;
84 const struct sja1105_private *priv = ctx;
85 const struct sja1105_regs *regs = priv->info->regs;
86 const int size = SJA1105_SIZE_PTP_CMD;
87 u8 buf[SJA1105_SIZE_PTP_CMD] = {0};
88
89 u64 valid = 1;
90
91 sja1105_pack(buf, &valid, 31, 31, size);
92 sja1105_pack(buf, &cmd->resptp, 2, 2, size);
93
94 return sja1105_spi_send_packed_buf(priv, SPI_WRITE, regs->ptp_control,
95 buf, SJA1105_SIZE_PTP_CMD);
96 }
97
98 int sja1105pqrs_ptp_cmd(const void *ctx, const void *data)
99 {
100 const struct sja1105_ptp_cmd *cmd = data;
101 const struct sja1105_private *priv = ctx;
102 const struct sja1105_regs *regs = priv->info->regs;
103 const int size = SJA1105_SIZE_PTP_CMD;
104 u8 buf[SJA1105_SIZE_PTP_CMD] = {0};
105
106 u64 valid = 1;
107
108 sja1105_pack(buf, &valid, 31, 31, size);
109 sja1105_pack(buf, &cmd->resptp, 3, 3, size);
110
111 return sja1105_spi_send_packed_buf(priv, SPI_WRITE, regs->ptp_control,
112 buf, SJA1105_SIZE_PTP_CMD);
113 }
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129 u64 sja1105_tstamp_reconstruct(struct sja1105_private *priv, u64 now,
130 u64 ts_partial)
131 {
132 u64 partial_tstamp_mask = CYCLECOUNTER_MASK(priv->info->ptp_ts_bits);
133 u64 ts_reconstructed;
134
135 ts_reconstructed = (now & ~partial_tstamp_mask) | ts_partial;
136
137
138
139
140
141 if ((now & partial_tstamp_mask) <= ts_partial)
142 ts_reconstructed -= (partial_tstamp_mask + 1);
143
144 return ts_reconstructed;
145 }
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173 int sja1105_ptpegr_ts_poll(struct sja1105_private *priv, int port, u64 *ts)
174 {
175 const struct sja1105_regs *regs = priv->info->regs;
176 int tstamp_bit_start, tstamp_bit_end;
177 int timeout = 10;
178 u8 packed_buf[8];
179 u64 update;
180 int rc;
181
182 do {
183 rc = sja1105_spi_send_packed_buf(priv, SPI_READ,
184 regs->ptpegr_ts[port],
185 packed_buf,
186 priv->info->ptpegr_ts_bytes);
187 if (rc < 0)
188 return rc;
189
190 sja1105_unpack(packed_buf, &update, 0, 0,
191 priv->info->ptpegr_ts_bytes);
192 if (update)
193 break;
194
195 usleep_range(10, 50);
196 } while (--timeout);
197
198 if (!timeout)
199 return -ETIMEDOUT;
200
201
202
203
204 tstamp_bit_end = (priv->info->ptpegr_ts_bytes - 4) * 8;
205
206
207
208 tstamp_bit_end += 32 - priv->info->ptp_ts_bits;
209 tstamp_bit_start = tstamp_bit_end + priv->info->ptp_ts_bits - 1;
210
211 *ts = 0;
212
213 sja1105_unpack(packed_buf, ts, tstamp_bit_start, tstamp_bit_end,
214 priv->info->ptpegr_ts_bytes);
215
216 return 0;
217 }
218
219 int sja1105_ptp_reset(struct sja1105_private *priv)
220 {
221 struct dsa_switch *ds = priv->ds;
222 struct sja1105_ptp_cmd cmd = {0};
223 int rc;
224
225 mutex_lock(&priv->ptp_lock);
226
227 cmd.resptp = 1;
228 dev_dbg(ds->dev, "Resetting PTP clock\n");
229 rc = priv->info->ptp_cmd(priv, &cmd);
230
231 timecounter_init(&priv->tstamp_tc, &priv->tstamp_cc,
232 ktime_to_ns(ktime_get_real()));
233
234 mutex_unlock(&priv->ptp_lock);
235
236 return rc;
237 }
238
239 static int sja1105_ptp_gettime(struct ptp_clock_info *ptp,
240 struct timespec64 *ts)
241 {
242 struct sja1105_private *priv = ptp_to_sja1105(ptp);
243 u64 ns;
244
245 mutex_lock(&priv->ptp_lock);
246 ns = timecounter_read(&priv->tstamp_tc);
247 mutex_unlock(&priv->ptp_lock);
248
249 *ts = ns_to_timespec64(ns);
250
251 return 0;
252 }
253
254 static int sja1105_ptp_settime(struct ptp_clock_info *ptp,
255 const struct timespec64 *ts)
256 {
257 struct sja1105_private *priv = ptp_to_sja1105(ptp);
258 u64 ns = timespec64_to_ns(ts);
259
260 mutex_lock(&priv->ptp_lock);
261 timecounter_init(&priv->tstamp_tc, &priv->tstamp_cc, ns);
262 mutex_unlock(&priv->ptp_lock);
263
264 return 0;
265 }
266
267 static int sja1105_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
268 {
269 struct sja1105_private *priv = ptp_to_sja1105(ptp);
270 s64 clkrate;
271
272 clkrate = (s64)scaled_ppm * SJA1105_CC_MULT_NUM;
273 clkrate = div_s64(clkrate, SJA1105_CC_MULT_DEM);
274
275 mutex_lock(&priv->ptp_lock);
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303 timecounter_read(&priv->tstamp_tc);
304
305 priv->tstamp_cc.mult = SJA1105_CC_MULT + clkrate;
306
307 mutex_unlock(&priv->ptp_lock);
308
309 return 0;
310 }
311
312 static int sja1105_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
313 {
314 struct sja1105_private *priv = ptp_to_sja1105(ptp);
315
316 mutex_lock(&priv->ptp_lock);
317 timecounter_adjtime(&priv->tstamp_tc, delta);
318 mutex_unlock(&priv->ptp_lock);
319
320 return 0;
321 }
322
323 static u64 sja1105_ptptsclk_read(const struct cyclecounter *cc)
324 {
325 struct sja1105_private *priv = cc_to_sja1105(cc);
326 const struct sja1105_regs *regs = priv->info->regs;
327 u64 ptptsclk = 0;
328 int rc;
329
330 rc = sja1105_spi_send_int(priv, SPI_READ, regs->ptptsclk,
331 &ptptsclk, 8);
332 if (rc < 0)
333 dev_err_ratelimited(priv->ds->dev,
334 "failed to read ptp cycle counter: %d\n",
335 rc);
336 return ptptsclk;
337 }
338
339 static void sja1105_ptp_overflow_check(struct work_struct *work)
340 {
341 struct delayed_work *dw = to_delayed_work(work);
342 struct sja1105_private *priv = dw_to_sja1105(dw);
343 struct timespec64 ts;
344
345 sja1105_ptp_gettime(&priv->ptp_caps, &ts);
346
347 schedule_delayed_work(&priv->refresh_work, SJA1105_REFRESH_INTERVAL);
348 }
349
350 static const struct ptp_clock_info sja1105_ptp_caps = {
351 .owner = THIS_MODULE,
352 .name = "SJA1105 PHC",
353 .adjfine = sja1105_ptp_adjfine,
354 .adjtime = sja1105_ptp_adjtime,
355 .gettime64 = sja1105_ptp_gettime,
356 .settime64 = sja1105_ptp_settime,
357 .max_adj = SJA1105_MAX_ADJ_PPB,
358 };
359
360 int sja1105_ptp_clock_register(struct sja1105_private *priv)
361 {
362 struct dsa_switch *ds = priv->ds;
363
364
365 priv->tstamp_cc = (struct cyclecounter) {
366 .read = sja1105_ptptsclk_read,
367 .mask = CYCLECOUNTER_MASK(64),
368 .shift = SJA1105_CC_SHIFT,
369 .mult = SJA1105_CC_MULT,
370 };
371 mutex_init(&priv->ptp_lock);
372 priv->ptp_caps = sja1105_ptp_caps;
373
374 priv->clock = ptp_clock_register(&priv->ptp_caps, ds->dev);
375 if (IS_ERR_OR_NULL(priv->clock))
376 return PTR_ERR(priv->clock);
377
378 INIT_DELAYED_WORK(&priv->refresh_work, sja1105_ptp_overflow_check);
379 schedule_delayed_work(&priv->refresh_work, SJA1105_REFRESH_INTERVAL);
380
381 return sja1105_ptp_reset(priv);
382 }
383
384 void sja1105_ptp_clock_unregister(struct sja1105_private *priv)
385 {
386 if (IS_ERR_OR_NULL(priv->clock))
387 return;
388
389 cancel_delayed_work_sync(&priv->refresh_work);
390 ptp_clock_unregister(priv->clock);
391 priv->clock = NULL;
392 }