1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * PTP 1588 clock support - User space test program
4 *
5 * Copyright (C) 2010 OMICRON electronics GmbH
6 */
7 #define _GNU_SOURCE
8 #define __SANE_USERSPACE_TYPES__ /* For PPC64, to get LL64 types */
9 #include <errno.h>
10 #include <fcntl.h>
11 #include <inttypes.h>
12 #include <math.h>
13 #include <signal.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <sys/ioctl.h>
18 #include <sys/mman.h>
19 #include <sys/stat.h>
20 #include <sys/time.h>
21 #include <sys/timex.h>
22 #include <sys/types.h>
23 #include <time.h>
24 #include <unistd.h>
25
26 #include <linux/ptp_clock.h>
27
28 #define DEVICE "/dev/ptp0"
29
30 #ifndef ADJ_SETOFFSET
31 #define ADJ_SETOFFSET 0x0100
32 #endif
33
34 #ifndef CLOCK_INVALID
35 #define CLOCK_INVALID -1
36 #endif
37
38 #define NSEC_PER_SEC 1000000000LL
39
40 /* clock_adjtime is not available in GLIBC < 2.14 */
41 #if !__GLIBC_PREREQ(2, 14)
42 #include <sys/syscall.h>
43 static int clock_adjtime(clockid_t id, struct timex *tx)
44 {
45 return syscall(__NR_clock_adjtime, id, tx);
46 }
47 #endif
48
49 static void show_flag_test(int rq_index, unsigned int flags, int err)
50 {
51 printf("PTP_EXTTS_REQUEST%c flags 0x%08x : (%d) %s\n",
52 rq_index ? '1' + rq_index : ' ',
53 flags, err, strerror(errno));
54 /* sigh, uClibc ... */
55 errno = 0;
56 }
57
58 static void do_flag_test(int fd, unsigned int index)
59 {
60 struct ptp_extts_request extts_request;
61 unsigned long request[2] = {
62 PTP_EXTTS_REQUEST,
63 PTP_EXTTS_REQUEST2,
64 };
65 unsigned int enable_flags[5] = {
66 PTP_ENABLE_FEATURE,
67 PTP_ENABLE_FEATURE | PTP_RISING_EDGE,
68 PTP_ENABLE_FEATURE | PTP_FALLING_EDGE,
69 PTP_ENABLE_FEATURE | PTP_RISING_EDGE | PTP_FALLING_EDGE,
70 PTP_ENABLE_FEATURE | (PTP_EXTTS_VALID_FLAGS + 1),
71 };
72 int err, i, j;
73
74 memset(&extts_request, 0, sizeof(extts_request));
75 extts_request.index = index;
76
77 for (i = 0; i < 2; i++) {
78 for (j = 0; j < 5; j++) {
79 extts_request.flags = enable_flags[j];
80 err = ioctl(fd, request[i], &extts_request);
81 show_flag_test(i, extts_request.flags, err);
82
83 extts_request.flags = 0;
84 err = ioctl(fd, request[i], &extts_request);
85 }
86 }
87 }
88
89 static clockid_t get_clockid(int fd)
90 {
91 #define CLOCKFD 3
92 return (((unsigned int) ~fd) << 3) | CLOCKFD;
93 }
94
95 static long ppb_to_scaled_ppm(int ppb)
96 {
97 /*
98 * The 'freq' field in the 'struct timex' is in parts per
99 * million, but with a 16 bit binary fractional field.
100 * Instead of calculating either one of
101 *
102 * scaled_ppm = (ppb / 1000) << 16 [1]
103 * scaled_ppm = (ppb << 16) / 1000 [2]
104 *
105 * we simply use double precision math, in order to avoid the
106 * truncation in [1] and the possible overflow in [2].
107 */
108 return (long) (ppb * 65.536);
109 }
110
111 static int64_t pctns(struct ptp_clock_time *t)
112 {
113 return t->sec * NSEC_PER_SEC + t->nsec;
114 }
115
116 static void usage(char *progname)
117 {
118 fprintf(stderr,
119 "usage: %s [options]\n"
120 " -c query the ptp clock's capabilities\n"
121 " -d name device to open\n"
122 " -e val read 'val' external time stamp events\n"
123 " -f val adjust the ptp clock frequency by 'val' ppb\n"
124 " -F chan Enable single channel mask and keep device open for debugfs verification.\n"
125 " -g get the ptp clock time\n"
126 " -h prints this message\n"
127 " -i val index for event/trigger\n"
128 " -k val measure the time offset between system and phc clock\n"
129 " for 'val' times (Maximum 25)\n"
130 " -l list the current pin configuration\n"
131 " -L pin,val configure pin index 'pin' with function 'val'\n"
132 " the channel index is taken from the '-i' option\n"
133 " 'val' specifies the auxiliary function:\n"
134 " 0 - none\n"
135 " 1 - external time stamp\n"
136 " 2 - periodic output\n"
137 " -n val shift the ptp clock time by 'val' nanoseconds\n"
138 " -o val phase offset (in nanoseconds) to be provided to the PHC servo\n"
139 " -p val enable output with a period of 'val' nanoseconds\n"
140 " -H val set output phase to 'val' nanoseconds (requires -p)\n"
141 " -w val set output pulse width to 'val' nanoseconds (requires -p)\n"
142 " -P val enable or disable (val=1|0) the system clock PPS\n"
143 " -s set the ptp clock time from the system time\n"
144 " -S set the system time from the ptp clock time\n"
145 " -t val shift the ptp clock time by 'val' seconds\n"
146 " -T val set the ptp clock time to 'val' seconds\n"
147 " -x val get an extended ptp clock time with the desired number of samples (up to %d)\n"
148 " -X get a ptp clock cross timestamp\n"
149 " -z test combinations of rising/falling external time stamp flags\n",
150 progname, PTP_MAX_SAMPLES);
151 }
152
153 int main(int argc, char *argv[])
154 {
155 struct ptp_clock_caps caps;
156 struct ptp_extts_event event;
157 struct ptp_extts_request extts_request;
158 struct ptp_perout_request perout_request;
159 struct ptp_pin_desc desc;
160 struct timespec ts;
161 struct timex tx;
162 struct ptp_clock_time *pct;
163 struct ptp_sys_offset *sysoff;
164 struct ptp_sys_offset_extended *soe;
165 struct ptp_sys_offset_precise *xts;
166
167 char *progname;
168 unsigned int i;
169 int c, cnt, fd;
170
171 char *device = DEVICE;
172 clockid_t clkid;
173 int adjfreq = 0x7fffffff;
174 int adjtime = 0;
175 int adjns = 0;
176 int adjphase = 0;
177 int capabilities = 0;
178 int extts = 0;
179 int flagtest = 0;
180 int gettime = 0;
181 int index = 0;
182 int list_pins = 0;
183 int pct_offset = 0;
184 int getextended = 0;
185 int getcross = 0;
186 int n_samples = 0;
187 int pin_index = -1, pin_func;
188 int pps = -1;
189 int seconds = 0;
190 int settime = 0;
191 int channel = -1;
192
193 int64_t t1, t2, tp;
194 int64_t interval, offset;
195 int64_t perout_phase = -1;
196 int64_t pulsewidth = -1;
197 int64_t perout = -1;
198
199 progname = strrchr(argv[0], '/');
200 progname = progname ? 1+progname : argv[0];
201 while (EOF != (c = getopt(argc, argv, "cd:e:f:F:ghH:i:k:lL:n:o:p:P:sSt:T:w:x:Xz"))) {
202 switch (c) {
203 case 'c':
204 capabilities = 1;
205 break;
206 case 'd':
207 device = optarg;
208 break;
209 case 'e':
210 extts = atoi(optarg);
211 break;
212 case 'f':
213 adjfreq = atoi(optarg);
214 break;
215 case 'F':
216 channel = atoi(optarg);
217 break;
218 case 'g':
219 gettime = 1;
220 break;
221 case 'H':
222 perout_phase = atoll(optarg);
223 break;
224 case 'i':
225 index = atoi(optarg);
226 break;
227 case 'k':
228 pct_offset = 1;
229 n_samples = atoi(optarg);
230 break;
231 case 'l':
232 list_pins = 1;
233 break;
234 case 'L':
235 cnt = sscanf(optarg, "%d,%d", &pin_index, &pin_func);
236 if (cnt != 2) {
237 usage(progname);
238 return -1;
239 }
240 break;
241 case 'n':
242 adjns = atoi(optarg);
243 break;
244 case 'o':
245 adjphase = atoi(optarg);
246 break;
247 case 'p':
248 perout = atoll(optarg);
249 break;
250 case 'P':
251 pps = atoi(optarg);
252 break;
253 case 's':
254 settime = 1;
255 break;
256 case 'S':
257 settime = 2;
258 break;
259 case 't':
260 adjtime = atoi(optarg);
261 break;
262 case 'T':
263 settime = 3;
264 seconds = atoi(optarg);
265 break;
266 case 'w':
267 pulsewidth = atoi(optarg);
268 break;
269 case 'x':
270 getextended = atoi(optarg);
271 if (getextended < 1 || getextended > PTP_MAX_SAMPLES) {
272 fprintf(stderr,
273 "number of extended timestamp samples must be between 1 and %d; was asked for %d\n",
274 PTP_MAX_SAMPLES, getextended);
275 return -1;
276 }
277 break;
278 case 'X':
279 getcross = 1;
280 break;
281 case 'z':
282 flagtest = 1;
283 break;
284 case 'h':
285 usage(progname);
286 return 0;
287 case '?':
288 default:
289 usage(progname);
290 return -1;
291 }
292 }
293
294 fd = open(device, O_RDWR);
295 if (fd < 0) {
296 fprintf(stderr, "opening %s: %s\n", device, strerror(errno));
297 return -1;
298 }
299
300 clkid = get_clockid(fd);
301 if (CLOCK_INVALID == clkid) {
302 fprintf(stderr, "failed to read clock id\n");
303 return -1;
304 }
305
306 if (capabilities) {
307 if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) {
308 perror("PTP_CLOCK_GETCAPS");
309 } else {
310 printf("capabilities:\n"
311 " %d maximum frequency adjustment (ppb)\n"
312 " %d programmable alarms\n"
313 " %d external time stamp channels\n"
314 " %d programmable periodic signals\n"
315 " %d pulse per second\n"
316 " %d programmable pins\n"
317 " %d cross timestamping\n"
318 " %d adjust_phase\n"
319 " %d maximum phase adjustment (ns)\n",
320 caps.max_adj,
321 caps.n_alarm,
322 caps.n_ext_ts,
323 caps.n_per_out,
324 caps.pps,
325 caps.n_pins,
326 caps.cross_timestamping,
327 caps.adjust_phase,
328 caps.max_phase_adj);
329 }
330 }
331
332 if (0x7fffffff != adjfreq) {
333 memset(&tx, 0, sizeof(tx));
334 tx.modes = ADJ_FREQUENCY;
335 tx.freq = ppb_to_scaled_ppm(adjfreq);
336 if (clock_adjtime(clkid, &tx)) {
337 perror("clock_adjtime");
338 } else {
339 puts("frequency adjustment okay");
340 }
341 }
342
343 if (adjtime || adjns) {
344 memset(&tx, 0, sizeof(tx));
345 tx.modes = ADJ_SETOFFSET | ADJ_NANO;
346 tx.time.tv_sec = adjtime;
347 tx.time.tv_usec = adjns;
348 while (tx.time.tv_usec < 0) {
349 tx.time.tv_sec -= 1;
350 tx.time.tv_usec += NSEC_PER_SEC;
351 }
352
353 if (clock_adjtime(clkid, &tx) < 0) {
354 perror("clock_adjtime");
355 } else {
356 puts("time shift okay");
357 }
358 }
359
360 if (adjphase) {
361 memset(&tx, 0, sizeof(tx));
362 tx.modes = ADJ_OFFSET | ADJ_NANO;
363 tx.offset = adjphase;
364
365 if (clock_adjtime(clkid, &tx) < 0) {
366 perror("clock_adjtime");
367 } else {
368 puts("phase adjustment okay");
369 }
370 }
371
372 if (gettime) {
373 if (clock_gettime(clkid, &ts)) {
374 perror("clock_gettime");
375 } else {
376 printf("clock time: %ld.%09ld or %s",
377 ts.tv_sec, ts.tv_nsec, ctime(&ts.tv_sec));
378 }
379 }
380
381 if (settime == 1) {
382 clock_gettime(CLOCK_REALTIME, &ts);
383 if (clock_settime(clkid, &ts)) {
384 perror("clock_settime");
385 } else {
386 puts("set time okay");
387 }
388 }
389
390 if (settime == 2) {
391 clock_gettime(clkid, &ts);
392 if (clock_settime(CLOCK_REALTIME, &ts)) {
393 perror("clock_settime");
394 } else {
395 puts("set time okay");
396 }
397 }
398
399 if (settime == 3) {
400 ts.tv_sec = seconds;
401 ts.tv_nsec = 0;
402 if (clock_settime(clkid, &ts)) {
403 perror("clock_settime");
404 } else {
405 puts("set time okay");
406 }
407 }
408
409 if (pin_index >= 0) {
410 memset(&desc, 0, sizeof(desc));
411 desc.index = pin_index;
412 desc.func = pin_func;
413 desc.chan = index;
414 if (ioctl(fd, PTP_PIN_SETFUNC, &desc)) {
415 perror("PTP_PIN_SETFUNC");
416 } else {
417 puts("set pin function okay");
418 }
419 }
420
421 if (extts) {
422 memset(&extts_request, 0, sizeof(extts_request));
423 extts_request.index = index;
424 extts_request.flags = PTP_ENABLE_FEATURE;
425 if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
426 perror("PTP_EXTTS_REQUEST");
427 extts = 0;
428 } else {
429 puts("external time stamp request okay");
430 }
431 for (; extts; extts--) {
432 cnt = read(fd, &event, sizeof(event));
433 if (cnt != sizeof(event)) {
434 perror("read");
435 break;
436 }
437 printf("event index %u at %lld.%09u\n", event.index,
438 event.t.sec, event.t.nsec);
439 fflush(stdout);
440 }
441 /* Disable the feature again. */
442 extts_request.flags = 0;
443 if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
444 perror("PTP_EXTTS_REQUEST");
445 }
446 }
447
448 if (flagtest) {
449 do_flag_test(fd, index);
450 }
451
452 if (list_pins) {
453 int n_pins = 0;
454 if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) {
455 perror("PTP_CLOCK_GETCAPS");
456 } else {
457 n_pins = caps.n_pins;
458 }
459 for (i = 0; i < n_pins; i++) {
460 desc.index = i;
461 if (ioctl(fd, PTP_PIN_GETFUNC, &desc)) {
462 perror("PTP_PIN_GETFUNC");
463 break;
464 }
465 printf("name %s index %u func %u chan %u\n",
466 desc.name, desc.index, desc.func, desc.chan);
467 }
468 }
469
470 if (pulsewidth >= 0 && perout < 0) {
471 puts("-w can only be specified together with -p");
472 return -1;
473 }
474
475 if (perout_phase >= 0 && perout < 0) {
476 puts("-H can only be specified together with -p");
477 return -1;
478 }
479
480 if (perout >= 0) {
481 if (clock_gettime(clkid, &ts)) {
482 perror("clock_gettime");
483 return -1;
484 }
485 memset(&perout_request, 0, sizeof(perout_request));
486 perout_request.index = index;
487 perout_request.period.sec = perout / NSEC_PER_SEC;
488 perout_request.period.nsec = perout % NSEC_PER_SEC;
489 perout_request.flags = 0;
490 if (pulsewidth >= 0) {
491 perout_request.flags |= PTP_PEROUT_DUTY_CYCLE;
492 perout_request.on.sec = pulsewidth / NSEC_PER_SEC;
493 perout_request.on.nsec = pulsewidth % NSEC_PER_SEC;
494 }
495 if (perout_phase >= 0) {
496 perout_request.flags |= PTP_PEROUT_PHASE;
497 perout_request.phase.sec = perout_phase / NSEC_PER_SEC;
498 perout_request.phase.nsec = perout_phase % NSEC_PER_SEC;
499 } else {
500 perout_request.start.sec = ts.tv_sec + 2;
501 perout_request.start.nsec = 0;
502 }
503
504 if (ioctl(fd, PTP_PEROUT_REQUEST2, &perout_request)) {
505 perror("PTP_PEROUT_REQUEST");
506 } else {
507 puts("periodic output request okay");
508 }
509 }
510
511 if (pps != -1) {
512 int enable = pps ? 1 : 0;
513 if (ioctl(fd, PTP_ENABLE_PPS, enable)) {
514 perror("PTP_ENABLE_PPS");
515 } else {
516 puts("pps for system time request okay");
517 }
518 }
519
520 if (pct_offset) {
521 if (n_samples <= 0 || n_samples > 25) {
522 puts("n_samples should be between 1 and 25");
523 usage(progname);
524 return -1;
525 }
526
527 sysoff = calloc(1, sizeof(*sysoff));
528 if (!sysoff) {
529 perror("calloc");
530 return -1;
531 }
532 sysoff->n_samples = n_samples;
533
534 if (ioctl(fd, PTP_SYS_OFFSET, sysoff))
535 perror("PTP_SYS_OFFSET");
536 else
537 puts("system and phc clock time offset request okay");
538
539 pct = &sysoff->ts[0];
540 for (i = 0; i < sysoff->n_samples; i++) {
541 t1 = pctns(pct+2*i);
542 tp = pctns(pct+2*i+1);
543 t2 = pctns(pct+2*i+2);
544 interval = t2 - t1;
545 offset = (t2 + t1) / 2 - tp;
546
547 printf("system time: %lld.%09u\n",
548 (pct+2*i)->sec, (pct+2*i)->nsec);
549 printf("phc time: %lld.%09u\n",
550 (pct+2*i+1)->sec, (pct+2*i+1)->nsec);
551 printf("system time: %lld.%09u\n",
552 (pct+2*i+2)->sec, (pct+2*i+2)->nsec);
553 printf("system/phc clock time offset is %" PRId64 " ns\n"
554 "system clock time delay is %" PRId64 " ns\n",
555 offset, interval);
556 }
557
558 free(sysoff);
559 }
560
561 if (getextended) {
562 soe = calloc(1, sizeof(*soe));
563 if (!soe) {
564 perror("calloc");
565 return -1;
566 }
567
568 soe->n_samples = getextended;
569
570 if (ioctl(fd, PTP_SYS_OFFSET_EXTENDED, soe)) {
571 perror("PTP_SYS_OFFSET_EXTENDED");
572 } else {
573 printf("extended timestamp request returned %d samples\n",
574 getextended);
575
576 for (i = 0; i < getextended; i++) {
577 printf("sample #%2d: system time before: %lld.%09u\n",
578 i, soe->ts[i][0].sec, soe->ts[i][0].nsec);
579 printf(" phc time: %lld.%09u\n",
580 soe->ts[i][1].sec, soe->ts[i][1].nsec);
581 printf(" system time after: %lld.%09u\n",
582 soe->ts[i][2].sec, soe->ts[i][2].nsec);
583 }
584 }
585
586 free(soe);
587 }
588
589 if (getcross) {
590 xts = calloc(1, sizeof(*xts));
591 if (!xts) {
592 perror("calloc");
593 return -1;
594 }
595
596 if (ioctl(fd, PTP_SYS_OFFSET_PRECISE, xts)) {
597 perror("PTP_SYS_OFFSET_PRECISE");
598 } else {
599 puts("system and phc crosstimestamping request okay");
600
601 printf("device time: %lld.%09u\n",
602 xts->device.sec, xts->device.nsec);
603 printf("system time: %lld.%09u\n",
604 xts->sys_realtime.sec, xts->sys_realtime.nsec);
605 printf("monoraw time: %lld.%09u\n",
606 xts->sys_monoraw.sec, xts->sys_monoraw.nsec);
607 }
608
609 free(xts);
610 }
611
612 if (channel >= 0) {
613 if (ioctl(fd, PTP_MASK_CLEAR_ALL)) {
614 perror("PTP_MASK_CLEAR_ALL");
615 } else if (ioctl(fd, PTP_MASK_EN_SINGLE, (unsigned int *)&channel)) {
616 perror("PTP_MASK_EN_SINGLE");
617 } else {
618 printf("Channel %d exclusively enabled. Check on debugfs.\n", channel);
619 printf("Press any key to continue\n.");
620 getchar();
621 }
622 }
623
624 close(fd);
625 return 0;
626 }
627
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.