1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell RVU Ethernet driver
3 *
4 * Copyright (C) 2020 Marvell.
5 *
6 */
7
8 #include <linux/module.h>
9
10 #include "otx2_common.h"
11 #include "otx2_ptp.h"
12
is_tstmp_atomic_update_supported(struct otx2_ptp * ptp)13 static bool is_tstmp_atomic_update_supported(struct otx2_ptp *ptp)
14 {
15 struct ptp_get_cap_rsp *rsp;
16 struct msg_req *req;
17 int err;
18
19 if (!ptp->nic)
20 return false;
21
22 mutex_lock(&ptp->nic->mbox.lock);
23 req = otx2_mbox_alloc_msg_ptp_get_cap(&ptp->nic->mbox);
24 if (!req) {
25 mutex_unlock(&ptp->nic->mbox.lock);
26 return false;
27 }
28
29 err = otx2_sync_mbox_msg(&ptp->nic->mbox);
30 if (err) {
31 mutex_unlock(&ptp->nic->mbox.lock);
32 return false;
33 }
34 rsp = (struct ptp_get_cap_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
35 &req->hdr);
36 mutex_unlock(&ptp->nic->mbox.lock);
37
38 if (IS_ERR(rsp))
39 return false;
40
41 if (rsp->cap & PTP_CAP_HW_ATOMIC_UPDATE)
42 return true;
43
44 return false;
45 }
46
otx2_ptp_hw_adjtime(struct ptp_clock_info * ptp_info,s64 delta)47 static int otx2_ptp_hw_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
48 {
49 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
50 ptp_info);
51 struct otx2_nic *pfvf = ptp->nic;
52 struct ptp_req *req;
53 int rc;
54
55 if (!ptp->nic)
56 return -ENODEV;
57
58 mutex_lock(&pfvf->mbox.lock);
59 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
60 if (!req) {
61 mutex_unlock(&pfvf->mbox.lock);
62 return -ENOMEM;
63 }
64 req->op = PTP_OP_ADJTIME;
65 req->delta = delta;
66 rc = otx2_sync_mbox_msg(&ptp->nic->mbox);
67 mutex_unlock(&pfvf->mbox.lock);
68
69 return rc;
70 }
71
otx2_ptp_get_clock(struct otx2_ptp * ptp)72 static u64 otx2_ptp_get_clock(struct otx2_ptp *ptp)
73 {
74 struct ptp_req *req;
75 struct ptp_rsp *rsp;
76 int err;
77
78 if (!ptp->nic)
79 return 0;
80
81 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
82 if (!req)
83 return 0;
84
85 req->op = PTP_OP_GET_CLOCK;
86
87 err = otx2_sync_mbox_msg(&ptp->nic->mbox);
88 if (err)
89 return 0;
90
91 rsp = (struct ptp_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
92 &req->hdr);
93 if (IS_ERR(rsp))
94 return 0;
95
96 return rsp->clk;
97 }
98
otx2_ptp_hw_gettime(struct ptp_clock_info * ptp_info,struct timespec64 * ts)99 static int otx2_ptp_hw_gettime(struct ptp_clock_info *ptp_info,
100 struct timespec64 *ts)
101 {
102 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
103 ptp_info);
104 u64 tstamp;
105
106 tstamp = otx2_ptp_get_clock(ptp);
107
108 *ts = ns_to_timespec64(tstamp);
109 return 0;
110 }
111
otx2_ptp_hw_settime(struct ptp_clock_info * ptp_info,const struct timespec64 * ts)112 static int otx2_ptp_hw_settime(struct ptp_clock_info *ptp_info,
113 const struct timespec64 *ts)
114 {
115 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
116 ptp_info);
117 struct otx2_nic *pfvf = ptp->nic;
118 struct ptp_req *req;
119 u64 nsec;
120 int rc;
121
122 if (!ptp->nic)
123 return -ENODEV;
124
125 nsec = timespec64_to_ns(ts);
126
127 mutex_lock(&pfvf->mbox.lock);
128 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
129 if (!req) {
130 mutex_unlock(&pfvf->mbox.lock);
131 return -ENOMEM;
132 }
133
134 req->op = PTP_OP_SET_CLOCK;
135 req->clk = nsec;
136 rc = otx2_sync_mbox_msg(&ptp->nic->mbox);
137 mutex_unlock(&pfvf->mbox.lock);
138
139 return rc;
140 }
141
otx2_ptp_adjfine(struct ptp_clock_info * ptp_info,long scaled_ppm)142 static int otx2_ptp_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm)
143 {
144 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
145 ptp_info);
146 struct ptp_req *req;
147
148 if (!ptp->nic)
149 return -ENODEV;
150
151 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
152 if (!req)
153 return -ENOMEM;
154
155 req->op = PTP_OP_ADJFINE;
156 req->scaled_ppm = scaled_ppm;
157
158 return otx2_sync_mbox_msg(&ptp->nic->mbox);
159 }
160
ptp_set_thresh(struct otx2_ptp * ptp,u64 thresh)161 static int ptp_set_thresh(struct otx2_ptp *ptp, u64 thresh)
162 {
163 struct ptp_req *req;
164
165 if (!ptp->nic)
166 return -ENODEV;
167
168 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
169 if (!req)
170 return -ENOMEM;
171
172 req->op = PTP_OP_SET_THRESH;
173 req->thresh = thresh;
174
175 return otx2_sync_mbox_msg(&ptp->nic->mbox);
176 }
177
ptp_extts_on(struct otx2_ptp * ptp,int on)178 static int ptp_extts_on(struct otx2_ptp *ptp, int on)
179 {
180 struct ptp_req *req;
181
182 if (!ptp->nic)
183 return -ENODEV;
184
185 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
186 if (!req)
187 return -ENOMEM;
188
189 req->op = PTP_OP_EXTTS_ON;
190 req->extts_on = on;
191
192 return otx2_sync_mbox_msg(&ptp->nic->mbox);
193 }
194
ptp_cc_read(const struct cyclecounter * cc)195 static u64 ptp_cc_read(const struct cyclecounter *cc)
196 {
197 struct otx2_ptp *ptp = container_of(cc, struct otx2_ptp, cycle_counter);
198
199 return otx2_ptp_get_clock(ptp);
200 }
201
ptp_tstmp_read(struct otx2_ptp * ptp)202 static u64 ptp_tstmp_read(struct otx2_ptp *ptp)
203 {
204 struct ptp_req *req;
205 struct ptp_rsp *rsp;
206 int err;
207
208 if (!ptp->nic)
209 return 0;
210
211 req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
212 if (!req)
213 return 0;
214
215 req->op = PTP_OP_GET_TSTMP;
216
217 err = otx2_sync_mbox_msg(&ptp->nic->mbox);
218 if (err)
219 return 0;
220
221 rsp = (struct ptp_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
222 &req->hdr);
223 if (IS_ERR(rsp))
224 return 0;
225
226 return rsp->clk;
227 }
228
otx2_ptp_tc_adjtime(struct ptp_clock_info * ptp_info,s64 delta)229 static int otx2_ptp_tc_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
230 {
231 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
232 ptp_info);
233 struct otx2_nic *pfvf = ptp->nic;
234
235 mutex_lock(&pfvf->mbox.lock);
236 timecounter_adjtime(&ptp->time_counter, delta);
237 mutex_unlock(&pfvf->mbox.lock);
238
239 return 0;
240 }
241
otx2_ptp_tc_gettime(struct ptp_clock_info * ptp_info,struct timespec64 * ts)242 static int otx2_ptp_tc_gettime(struct ptp_clock_info *ptp_info,
243 struct timespec64 *ts)
244 {
245 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
246 ptp_info);
247 u64 tstamp;
248
249 mutex_lock(&ptp->nic->mbox.lock);
250 tstamp = timecounter_read(&ptp->time_counter);
251 mutex_unlock(&ptp->nic->mbox.lock);
252 *ts = ns_to_timespec64(tstamp);
253
254 return 0;
255 }
256
otx2_ptp_tc_settime(struct ptp_clock_info * ptp_info,const struct timespec64 * ts)257 static int otx2_ptp_tc_settime(struct ptp_clock_info *ptp_info,
258 const struct timespec64 *ts)
259 {
260 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
261 ptp_info);
262 u64 nsec;
263
264 nsec = timespec64_to_ns(ts);
265
266 mutex_lock(&ptp->nic->mbox.lock);
267 timecounter_init(&ptp->time_counter, &ptp->cycle_counter, nsec);
268 mutex_unlock(&ptp->nic->mbox.lock);
269
270 return 0;
271 }
272
otx2_ptp_verify_pin(struct ptp_clock_info * ptp,unsigned int pin,enum ptp_pin_function func,unsigned int chan)273 static int otx2_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
274 enum ptp_pin_function func, unsigned int chan)
275 {
276 switch (func) {
277 case PTP_PF_NONE:
278 case PTP_PF_EXTTS:
279 break;
280 case PTP_PF_PEROUT:
281 case PTP_PF_PHYSYNC:
282 return -1;
283 }
284 return 0;
285 }
286
otx2_ptp_hw_tstamp2time(const struct timecounter * time_counter,u64 tstamp)287 static u64 otx2_ptp_hw_tstamp2time(const struct timecounter *time_counter, u64 tstamp)
288 {
289 /* On HW which supports atomic updates, timecounter is not initialized */
290 return tstamp;
291 }
292
otx2_ptp_extts_check(struct work_struct * work)293 static void otx2_ptp_extts_check(struct work_struct *work)
294 {
295 struct otx2_ptp *ptp = container_of(work, struct otx2_ptp,
296 extts_work.work);
297 struct ptp_clock_event event;
298 u64 tstmp, new_thresh;
299
300 mutex_lock(&ptp->nic->mbox.lock);
301 tstmp = ptp_tstmp_read(ptp);
302 mutex_unlock(&ptp->nic->mbox.lock);
303
304 if (tstmp != ptp->last_extts) {
305 event.type = PTP_CLOCK_EXTTS;
306 event.index = 0;
307 event.timestamp = ptp->ptp_tstamp2nsec(&ptp->time_counter, tstmp);
308 ptp_clock_event(ptp->ptp_clock, &event);
309 new_thresh = tstmp % 500000000;
310 if (ptp->thresh != new_thresh) {
311 mutex_lock(&ptp->nic->mbox.lock);
312 ptp_set_thresh(ptp, new_thresh);
313 mutex_unlock(&ptp->nic->mbox.lock);
314 ptp->thresh = new_thresh;
315 }
316 ptp->last_extts = tstmp;
317 }
318 schedule_delayed_work(&ptp->extts_work, msecs_to_jiffies(200));
319 }
320
otx2_sync_tstamp(struct work_struct * work)321 static void otx2_sync_tstamp(struct work_struct *work)
322 {
323 struct otx2_ptp *ptp = container_of(work, struct otx2_ptp,
324 synctstamp_work.work);
325 struct otx2_nic *pfvf = ptp->nic;
326 u64 tstamp;
327
328 mutex_lock(&pfvf->mbox.lock);
329 tstamp = otx2_ptp_get_clock(ptp);
330 mutex_unlock(&pfvf->mbox.lock);
331
332 ptp->tstamp = ptp->ptp_tstamp2nsec(&ptp->time_counter, tstamp);
333 ptp->base_ns = tstamp % NSEC_PER_SEC;
334
335 schedule_delayed_work(&ptp->synctstamp_work, msecs_to_jiffies(250));
336 }
337
otx2_ptp_enable(struct ptp_clock_info * ptp_info,struct ptp_clock_request * rq,int on)338 static int otx2_ptp_enable(struct ptp_clock_info *ptp_info,
339 struct ptp_clock_request *rq, int on)
340 {
341 struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
342 ptp_info);
343 int pin;
344
345 if (!ptp->nic)
346 return -ENODEV;
347
348 switch (rq->type) {
349 case PTP_CLK_REQ_EXTTS:
350 pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_EXTTS,
351 rq->extts.index);
352 if (pin < 0)
353 return -EBUSY;
354 if (on) {
355 ptp_extts_on(ptp, on);
356 schedule_delayed_work(&ptp->extts_work, msecs_to_jiffies(200));
357 } else {
358 ptp_extts_on(ptp, on);
359 cancel_delayed_work_sync(&ptp->extts_work);
360 }
361 return 0;
362 default:
363 break;
364 }
365 return -EOPNOTSUPP;
366 }
367
otx2_ptp_init(struct otx2_nic * pfvf)368 int otx2_ptp_init(struct otx2_nic *pfvf)
369 {
370 struct otx2_ptp *ptp_ptr;
371 struct cyclecounter *cc;
372 struct ptp_req *req;
373 int err;
374
375 if (is_otx2_lbkvf(pfvf->pdev)) {
376 pfvf->ptp = NULL;
377 return 0;
378 }
379
380 mutex_lock(&pfvf->mbox.lock);
381 /* check if PTP block is available */
382 req = otx2_mbox_alloc_msg_ptp_op(&pfvf->mbox);
383 if (!req) {
384 mutex_unlock(&pfvf->mbox.lock);
385 return -ENOMEM;
386 }
387
388 req->op = PTP_OP_GET_CLOCK;
389
390 err = otx2_sync_mbox_msg(&pfvf->mbox);
391 if (err) {
392 mutex_unlock(&pfvf->mbox.lock);
393 return err;
394 }
395 mutex_unlock(&pfvf->mbox.lock);
396
397 ptp_ptr = kzalloc(sizeof(*ptp_ptr), GFP_KERNEL);
398 if (!ptp_ptr) {
399 err = -ENOMEM;
400 goto error;
401 }
402
403 ptp_ptr->nic = pfvf;
404
405 snprintf(ptp_ptr->extts_config.name, sizeof(ptp_ptr->extts_config.name), "TSTAMP");
406 ptp_ptr->extts_config.index = 0;
407 ptp_ptr->extts_config.func = PTP_PF_NONE;
408
409 ptp_ptr->ptp_info = (struct ptp_clock_info) {
410 .owner = THIS_MODULE,
411 .name = "OcteonTX2 PTP",
412 .max_adj = 1000000000ull,
413 .n_ext_ts = 1,
414 .n_pins = 1,
415 .pps = 0,
416 .pin_config = &ptp_ptr->extts_config,
417 .adjfine = otx2_ptp_adjfine,
418 .enable = otx2_ptp_enable,
419 .verify = otx2_ptp_verify_pin,
420 };
421
422 /* Check whether hardware supports atomic updates to timestamp */
423 if (is_tstmp_atomic_update_supported(ptp_ptr)) {
424 ptp_ptr->ptp_info.adjtime = otx2_ptp_hw_adjtime;
425 ptp_ptr->ptp_info.gettime64 = otx2_ptp_hw_gettime;
426 ptp_ptr->ptp_info.settime64 = otx2_ptp_hw_settime;
427
428 ptp_ptr->ptp_tstamp2nsec = otx2_ptp_hw_tstamp2time;
429 } else {
430 ptp_ptr->ptp_info.adjtime = otx2_ptp_tc_adjtime;
431 ptp_ptr->ptp_info.gettime64 = otx2_ptp_tc_gettime;
432 ptp_ptr->ptp_info.settime64 = otx2_ptp_tc_settime;
433
434 cc = &ptp_ptr->cycle_counter;
435 cc->read = ptp_cc_read;
436 cc->mask = CYCLECOUNTER_MASK(64);
437 cc->mult = 1;
438 cc->shift = 0;
439 ptp_ptr->ptp_tstamp2nsec = timecounter_cyc2time;
440
441 timecounter_init(&ptp_ptr->time_counter, &ptp_ptr->cycle_counter,
442 ktime_to_ns(ktime_get_real()));
443 }
444
445 INIT_DELAYED_WORK(&ptp_ptr->extts_work, otx2_ptp_extts_check);
446
447 ptp_ptr->ptp_clock = ptp_clock_register(&ptp_ptr->ptp_info, pfvf->dev);
448 if (IS_ERR_OR_NULL(ptp_ptr->ptp_clock)) {
449 err = ptp_ptr->ptp_clock ?
450 PTR_ERR(ptp_ptr->ptp_clock) : -ENODEV;
451 kfree(ptp_ptr);
452 goto error;
453 }
454
455 if (is_dev_otx2(pfvf->pdev)) {
456 ptp_ptr->convert_rx_ptp_tstmp = &otx2_ptp_convert_rx_timestamp;
457 ptp_ptr->convert_tx_ptp_tstmp = &otx2_ptp_convert_tx_timestamp;
458 } else {
459 ptp_ptr->convert_rx_ptp_tstmp = &cn10k_ptp_convert_timestamp;
460 ptp_ptr->convert_tx_ptp_tstmp = &cn10k_ptp_convert_timestamp;
461 }
462
463 INIT_DELAYED_WORK(&ptp_ptr->synctstamp_work, otx2_sync_tstamp);
464
465 pfvf->ptp = ptp_ptr;
466
467 error:
468 return err;
469 }
470 EXPORT_SYMBOL_GPL(otx2_ptp_init);
471
otx2_ptp_destroy(struct otx2_nic * pfvf)472 void otx2_ptp_destroy(struct otx2_nic *pfvf)
473 {
474 struct otx2_ptp *ptp = pfvf->ptp;
475
476 if (!ptp)
477 return;
478
479 cancel_delayed_work(&pfvf->ptp->synctstamp_work);
480
481 ptp_clock_unregister(ptp->ptp_clock);
482 kfree(ptp);
483 pfvf->ptp = NULL;
484 }
485 EXPORT_SYMBOL_GPL(otx2_ptp_destroy);
486
otx2_ptp_clock_index(struct otx2_nic * pfvf)487 int otx2_ptp_clock_index(struct otx2_nic *pfvf)
488 {
489 if (!pfvf->ptp)
490 return -ENODEV;
491
492 return ptp_clock_index(pfvf->ptp->ptp_clock);
493 }
494 EXPORT_SYMBOL_GPL(otx2_ptp_clock_index);
495
otx2_ptp_tstamp2time(struct otx2_nic * pfvf,u64 tstamp,u64 * tsns)496 int otx2_ptp_tstamp2time(struct otx2_nic *pfvf, u64 tstamp, u64 *tsns)
497 {
498 if (!pfvf->ptp)
499 return -ENODEV;
500
501 *tsns = pfvf->ptp->ptp_tstamp2nsec(&pfvf->ptp->time_counter, tstamp);
502
503 return 0;
504 }
505 EXPORT_SYMBOL_GPL(otx2_ptp_tstamp2time);
506
507 MODULE_AUTHOR("Sunil Goutham <sgoutham@marvell.com>");
508 MODULE_DESCRIPTION("Marvell RVU NIC PTP Driver");
509 MODULE_LICENSE("GPL v2");
510