1/* 2 * PTP 1588 clock support - User space test program 3 * 4 * Copyright (C) 2010 OMICRON electronics GmbH 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20#define _GNU_SOURCE 21#define __SANE_USERSPACE_TYPES__ /* For PPC64, to get LL64 types */ 22#include <errno.h> 23#include <fcntl.h> 24#include <inttypes.h> 25#include <math.h> 26#include <signal.h> 27#include <stdio.h> 28#include <stdlib.h> 29#include <string.h> 30#include <sys/ioctl.h> 31#include <sys/mman.h> 32#include <sys/stat.h> 33#include <sys/time.h> 34#include <sys/timex.h> 35#include <sys/types.h> 36#include <time.h> 37#include <unistd.h> 38 39#include <linux/ptp_clock.h> 40 41#define DEVICE "/dev/ptp0" 42 43#ifndef ADJ_SETOFFSET 44#define ADJ_SETOFFSET 0x0100 45#endif 46 47#ifndef CLOCK_INVALID 48#define CLOCK_INVALID -1 49#endif 50 51/* clock_adjtime is not available in GLIBC < 2.14 */ 52#if !__GLIBC_PREREQ(2, 14) 53#include <sys/syscall.h> 54static int clock_adjtime(clockid_t id, struct timex *tx) 55{ 56 return syscall(__NR_clock_adjtime, id, tx); 57} 58#endif 59 60static clockid_t get_clockid(int fd) 61{ 62#define CLOCKFD 3 63#define FD_TO_CLOCKID(fd) ((~(clockid_t) (fd) << 3) | CLOCKFD) 64 65 return FD_TO_CLOCKID(fd); 66} 67 68static void handle_alarm(int s) 69{ 70 printf("received signal %d\n", s); 71} 72 73static int install_handler(int signum, void (*handler)(int)) 74{ 75 struct sigaction action; 76 sigset_t mask; 77 78 /* Unblock the signal. */ 79 sigemptyset(&mask); 80 sigaddset(&mask, signum); 81 sigprocmask(SIG_UNBLOCK, &mask, NULL); 82 83 /* Install the signal handler. */ 84 action.sa_handler = handler; 85 action.sa_flags = 0; 86 sigemptyset(&action.sa_mask); 87 sigaction(signum, &action, NULL); 88 89 return 0; 90} 91 92static long ppb_to_scaled_ppm(int ppb) 93{ 94 /* 95 * The 'freq' field in the 'struct timex' is in parts per 96 * million, but with a 16 bit binary fractional field. 97 * Instead of calculating either one of 98 * 99 * scaled_ppm = (ppb / 1000) << 16 [1] 100 * scaled_ppm = (ppb << 16) / 1000 [2] 101 * 102 * we simply use double precision math, in order to avoid the 103 * truncation in [1] and the possible overflow in [2]. 104 */ 105 return (long) (ppb * 65.536); 106} 107 108static int64_t pctns(struct ptp_clock_time *t) 109{ 110 return t->sec * 1000000000LL + t->nsec; 111} 112 113static void usage(char *progname) 114{ 115 fprintf(stderr, 116 "usage: %s [options]\n" 117 " -a val request a one-shot alarm after 'val' seconds\n" 118 " -A val request a periodic alarm every 'val' seconds\n" 119 " -c query the ptp clock's capabilities\n" 120 " -d name device to open\n" 121 " -e val read 'val' external time stamp events\n" 122 " -f val adjust the ptp clock frequency by 'val' ppb\n" 123 " -g get the ptp clock time\n" 124 " -h prints this message\n" 125 " -i val index for event/trigger\n" 126 " -k val measure the time offset between system and phc clock\n" 127 " for 'val' times (Maximum 25)\n" 128 " -l list the current pin configuration\n" 129 " -L pin,val configure pin index 'pin' with function 'val'\n" 130 " the channel index is taken from the '-i' option\n" 131 " 'val' specifies the auxiliary function:\n" 132 " 0 - none\n" 133 " 1 - external time stamp\n" 134 " 2 - periodic output\n" 135 " -p val enable output with a period of 'val' nanoseconds\n" 136 " -P val enable or disable (val=1|0) the system clock PPS\n" 137 " -s set the ptp clock time from the system time\n" 138 " -S set the system time from the ptp clock time\n" 139 " -t val shift the ptp clock time by 'val' seconds\n" 140 " -T val set the ptp clock time to 'val' seconds\n", 141 progname); 142} 143 144int main(int argc, char *argv[]) 145{ 146 struct ptp_clock_caps caps; 147 struct ptp_extts_event event; 148 struct ptp_extts_request extts_request; 149 struct ptp_perout_request perout_request; 150 struct ptp_pin_desc desc; 151 struct timespec ts; 152 struct timex tx; 153 154 static timer_t timerid; 155 struct itimerspec timeout; 156 struct sigevent sigevent; 157 158 struct ptp_clock_time *pct; 159 struct ptp_sys_offset *sysoff; 160 161 162 char *progname; 163 int i, c, cnt, fd; 164 165 char *device = DEVICE; 166 clockid_t clkid; 167 int adjfreq = 0x7fffffff; 168 int adjtime = 0; 169 int capabilities = 0; 170 int extts = 0; 171 int gettime = 0; 172 int index = 0; 173 int list_pins = 0; 174 int oneshot = 0; 175 int pct_offset = 0; 176 int n_samples = 0; 177 int periodic = 0; 178 int perout = -1; 179 int pin_index = -1, pin_func; 180 int pps = -1; 181 int seconds = 0; 182 int settime = 0; 183 184 int64_t t1, t2, tp; 185 int64_t interval, offset; 186 187 progname = strrchr(argv[0], '/'); 188 progname = progname ? 1+progname : argv[0]; 189 while (EOF != (c = getopt(argc, argv, "a:A:cd:e:f:ghi:k:lL:p:P:sSt:T:v"))) { 190 switch (c) { 191 case 'a': 192 oneshot = atoi(optarg); 193 break; 194 case 'A': 195 periodic = atoi(optarg); 196 break; 197 case 'c': 198 capabilities = 1; 199 break; 200 case 'd': 201 device = optarg; 202 break; 203 case 'e': 204 extts = atoi(optarg); 205 break; 206 case 'f': 207 adjfreq = atoi(optarg); 208 break; 209 case 'g': 210 gettime = 1; 211 break; 212 case 'i': 213 index = atoi(optarg); 214 break; 215 case 'k': 216 pct_offset = 1; 217 n_samples = atoi(optarg); 218 break; 219 case 'l': 220 list_pins = 1; 221 break; 222 case 'L': 223 cnt = sscanf(optarg, "%d,%d", &pin_index, &pin_func); 224 if (cnt != 2) { 225 usage(progname); 226 return -1; 227 } 228 break; 229 case 'p': 230 perout = atoi(optarg); 231 break; 232 case 'P': 233 pps = atoi(optarg); 234 break; 235 case 's': 236 settime = 1; 237 break; 238 case 'S': 239 settime = 2; 240 break; 241 case 't': 242 adjtime = atoi(optarg); 243 break; 244 case 'T': 245 settime = 3; 246 seconds = atoi(optarg); 247 break; 248 case 'h': 249 usage(progname); 250 return 0; 251 case '?': 252 default: 253 usage(progname); 254 return -1; 255 } 256 } 257 258 fd = open(device, O_RDWR); 259 if (fd < 0) { 260 fprintf(stderr, "opening %s: %s\n", device, strerror(errno)); 261 return -1; 262 } 263 264 clkid = get_clockid(fd); 265 if (CLOCK_INVALID == clkid) { 266 fprintf(stderr, "failed to read clock id\n"); 267 return -1; 268 } 269 270 if (capabilities) { 271 if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) { 272 perror("PTP_CLOCK_GETCAPS"); 273 } else { 274 printf("capabilities:\n" 275 " %d maximum frequency adjustment (ppb)\n" 276 " %d programmable alarms\n" 277 " %d external time stamp channels\n" 278 " %d programmable periodic signals\n" 279 " %d pulse per second\n" 280 " %d programmable pins\n", 281 caps.max_adj, 282 caps.n_alarm, 283 caps.n_ext_ts, 284 caps.n_per_out, 285 caps.pps, 286 caps.n_pins); 287 } 288 } 289 290 if (0x7fffffff != adjfreq) { 291 memset(&tx, 0, sizeof(tx)); 292 tx.modes = ADJ_FREQUENCY; 293 tx.freq = ppb_to_scaled_ppm(adjfreq); 294 if (clock_adjtime(clkid, &tx)) { 295 perror("clock_adjtime"); 296 } else { 297 puts("frequency adjustment okay"); 298 } 299 } 300 301 if (adjtime) { 302 memset(&tx, 0, sizeof(tx)); 303 tx.modes = ADJ_SETOFFSET; 304 tx.time.tv_sec = adjtime; 305 tx.time.tv_usec = 0; 306 if (clock_adjtime(clkid, &tx) < 0) { 307 perror("clock_adjtime"); 308 } else { 309 puts("time shift okay"); 310 } 311 } 312 313 if (gettime) { 314 if (clock_gettime(clkid, &ts)) { 315 perror("clock_gettime"); 316 } else { 317 printf("clock time: %ld.%09ld or %s", 318 ts.tv_sec, ts.tv_nsec, ctime(&ts.tv_sec)); 319 } 320 } 321 322 if (settime == 1) { 323 clock_gettime(CLOCK_REALTIME, &ts); 324 if (clock_settime(clkid, &ts)) { 325 perror("clock_settime"); 326 } else { 327 puts("set time okay"); 328 } 329 } 330 331 if (settime == 2) { 332 clock_gettime(clkid, &ts); 333 if (clock_settime(CLOCK_REALTIME, &ts)) { 334 perror("clock_settime"); 335 } else { 336 puts("set time okay"); 337 } 338 } 339 340 if (settime == 3) { 341 ts.tv_sec = seconds; 342 ts.tv_nsec = 0; 343 if (clock_settime(clkid, &ts)) { 344 perror("clock_settime"); 345 } else { 346 puts("set time okay"); 347 } 348 } 349 350 if (extts) { 351 memset(&extts_request, 0, sizeof(extts_request)); 352 extts_request.index = index; 353 extts_request.flags = PTP_ENABLE_FEATURE; 354 if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) { 355 perror("PTP_EXTTS_REQUEST"); 356 extts = 0; 357 } else { 358 puts("external time stamp request okay"); 359 } 360 for (; extts; extts--) { 361 cnt = read(fd, &event, sizeof(event)); 362 if (cnt != sizeof(event)) { 363 perror("read"); 364 break; 365 } 366 printf("event index %u at %lld.%09u\n", event.index, 367 event.t.sec, event.t.nsec); 368 fflush(stdout); 369 } 370 /* Disable the feature again. */ 371 extts_request.flags = 0; 372 if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) { 373 perror("PTP_EXTTS_REQUEST"); 374 } 375 } 376 377 if (list_pins) { 378 int n_pins = 0; 379 if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) { 380 perror("PTP_CLOCK_GETCAPS"); 381 } else { 382 n_pins = caps.n_pins; 383 } 384 for (i = 0; i < n_pins; i++) { 385 desc.index = i; 386 if (ioctl(fd, PTP_PIN_GETFUNC, &desc)) { 387 perror("PTP_PIN_GETFUNC"); 388 break; 389 } 390 printf("name %s index %u func %u chan %u\n", 391 desc.name, desc.index, desc.func, desc.chan); 392 } 393 } 394 395 if (oneshot) { 396 install_handler(SIGALRM, handle_alarm); 397 /* Create a timer. */ 398 sigevent.sigev_notify = SIGEV_SIGNAL; 399 sigevent.sigev_signo = SIGALRM; 400 if (timer_create(clkid, &sigevent, &timerid)) { 401 perror("timer_create"); 402 return -1; 403 } 404 /* Start the timer. */ 405 memset(&timeout, 0, sizeof(timeout)); 406 timeout.it_value.tv_sec = oneshot; 407 if (timer_settime(timerid, 0, &timeout, NULL)) { 408 perror("timer_settime"); 409 return -1; 410 } 411 pause(); 412 timer_delete(timerid); 413 } 414 415 if (periodic) { 416 install_handler(SIGALRM, handle_alarm); 417 /* Create a timer. */ 418 sigevent.sigev_notify = SIGEV_SIGNAL; 419 sigevent.sigev_signo = SIGALRM; 420 if (timer_create(clkid, &sigevent, &timerid)) { 421 perror("timer_create"); 422 return -1; 423 } 424 /* Start the timer. */ 425 memset(&timeout, 0, sizeof(timeout)); 426 timeout.it_interval.tv_sec = periodic; 427 timeout.it_value.tv_sec = periodic; 428 if (timer_settime(timerid, 0, &timeout, NULL)) { 429 perror("timer_settime"); 430 return -1; 431 } 432 while (1) { 433 pause(); 434 } 435 timer_delete(timerid); 436 } 437 438 if (perout >= 0) { 439 if (clock_gettime(clkid, &ts)) { 440 perror("clock_gettime"); 441 return -1; 442 } 443 memset(&perout_request, 0, sizeof(perout_request)); 444 perout_request.index = index; 445 perout_request.start.sec = ts.tv_sec + 2; 446 perout_request.start.nsec = 0; 447 perout_request.period.sec = 0; 448 perout_request.period.nsec = perout; 449 if (ioctl(fd, PTP_PEROUT_REQUEST, &perout_request)) { 450 perror("PTP_PEROUT_REQUEST"); 451 } else { 452 puts("periodic output request okay"); 453 } 454 } 455 456 if (pin_index >= 0) { 457 memset(&desc, 0, sizeof(desc)); 458 desc.index = pin_index; 459 desc.func = pin_func; 460 desc.chan = index; 461 if (ioctl(fd, PTP_PIN_SETFUNC, &desc)) { 462 perror("PTP_PIN_SETFUNC"); 463 } else { 464 puts("set pin function okay"); 465 } 466 } 467 468 if (pps != -1) { 469 int enable = pps ? 1 : 0; 470 if (ioctl(fd, PTP_ENABLE_PPS, enable)) { 471 perror("PTP_ENABLE_PPS"); 472 } else { 473 puts("pps for system time request okay"); 474 } 475 } 476 477 if (pct_offset) { 478 if (n_samples <= 0 || n_samples > 25) { 479 puts("n_samples should be between 1 and 25"); 480 usage(progname); 481 return -1; 482 } 483 484 sysoff = calloc(1, sizeof(*sysoff)); 485 if (!sysoff) { 486 perror("calloc"); 487 return -1; 488 } 489 sysoff->n_samples = n_samples; 490 491 if (ioctl(fd, PTP_SYS_OFFSET, sysoff)) 492 perror("PTP_SYS_OFFSET"); 493 else 494 puts("system and phc clock time offset request okay"); 495 496 pct = &sysoff->ts[0]; 497 for (i = 0; i < sysoff->n_samples; i++) { 498 t1 = pctns(pct+2*i); 499 tp = pctns(pct+2*i+1); 500 t2 = pctns(pct+2*i+2); 501 interval = t2 - t1; 502 offset = (t2 + t1) / 2 - tp; 503 504 printf("system time: %lld.%u\n", 505 (pct+2*i)->sec, (pct+2*i)->nsec); 506 printf("phc time: %lld.%u\n", 507 (pct+2*i+1)->sec, (pct+2*i+1)->nsec); 508 printf("system time: %lld.%u\n", 509 (pct+2*i+2)->sec, (pct+2*i+2)->nsec); 510 printf("system/phc clock time offset is %" PRId64 " ns\n" 511 "system clock time delay is %" PRId64 " ns\n", 512 offset, interval); 513 } 514 515 free(sysoff); 516 } 517 518 close(fd); 519 return 0; 520} 521