ptp: Added a brand new class driver for ptp clocks. (d94ba80e) · Commits · e / devices / android_kernel_fairphone_FP5

Documentation/ABI/testing/sysfs-ptp

0 → 100644

+98 −0

Original line number	Diff line number	Diff line
		What: /sys/class/ptp/
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This directory contains files and directories
		providing a standardized interface to the ancillary
		features of PTP hardware clocks.

		What: /sys/class/ptp/ptpN/
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This directory contains the attributes of the Nth PTP
		hardware clock registered into the PTP class driver
		subsystem.

		What: /sys/class/ptp/ptpN/clock_name
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file contains the name of the PTP hardware clock
		as a human readable string.

		What: /sys/class/ptp/ptpN/max_adjustment
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file contains the PTP hardware clock's maximum
		frequency adjustment value (a positive integer) in
		parts per billion.

		What: /sys/class/ptp/ptpN/n_alarms
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file contains the number of periodic or one shot
		alarms offer by the PTP hardware clock.

		What: /sys/class/ptp/ptpN/n_external_timestamps
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file contains the number of external timestamp
		channels offered by the PTP hardware clock.

		What: /sys/class/ptp/ptpN/n_periodic_outputs
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file contains the number of programmable periodic
		output channels offered by the PTP hardware clock.

		What: /sys/class/ptp/ptpN/pps_avaiable
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file indicates whether the PTP hardware clock
		supports a Pulse Per Second to the host CPU. Reading
		"1" means that the PPS is supported, while "0" means
		not supported.

		What: /sys/class/ptp/ptpN/extts_enable
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This write-only file enables or disables external
		timestamps. To enable external timestamps, write the
		channel index followed by a "1" into the file.
		To disable external timestamps, write the channel
		index followed by a "0" into the file.

		What: /sys/class/ptp/ptpN/fifo
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This file provides timestamps on external events, in
		the form of three integers: channel index, seconds,
		and nanoseconds.

		What: /sys/class/ptp/ptpN/period
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This write-only file enables or disables periodic
		outputs. To enable a periodic output, write five
		integers into the file: channel index, start time
		seconds, start time nanoseconds, period seconds, and
		period nanoseconds. To disable a periodic output, set
		all the seconds and nanoseconds values to zero.

		What: /sys/class/ptp/ptpN/pps_enable
		Date: September 2010
		Contact: Richard Cochran <richardcochran@gmail.com>
		Description:
		This write-only file enables or disables delivery of
		PPS events to the Linux PPS subsystem. To enable PPS
		events, write a "1" into the file. To disable events,
		write a "0" into the file.

Documentation/ptp/ptp.txt

0 → 100644

+89 −0

Original line number	Diff line number	Diff line

		* PTP hardware clock infrastructure for Linux

		This patch set introduces support for IEEE 1588 PTP clocks in
		Linux. Together with the SO_TIMESTAMPING socket options, this
		presents a standardized method for developing PTP user space
		programs, synchronizing Linux with external clocks, and using the
		ancillary features of PTP hardware clocks.

		A new class driver exports a kernel interface for specific clock
		drivers and a user space interface. The infrastructure supports a
		complete set of PTP hardware clock functionality.

		+ Basic clock operations
		- Set time
		- Get time
		- Shift the clock by a given offset atomically
		- Adjust clock frequency

		+ Ancillary clock features
		- One short or periodic alarms, with signal delivery to user program
		- Time stamp external events
		- Period output signals configurable from user space
		- Synchronization of the Linux system time via the PPS subsystem

		** PTP hardware clock kernel API

		A PTP clock driver registers itself with the class driver. The
		class driver handles all of the dealings with user space. The
		author of a clock driver need only implement the details of
		programming the clock hardware. The clock driver notifies the class
		driver of asynchronous events (alarms and external time stamps) via
		a simple message passing interface.

		The class driver supports multiple PTP clock drivers. In normal use
		cases, only one PTP clock is needed. However, for testing and
		development, it can be useful to have more than one clock in a
		single system, in order to allow performance comparisons.

		** PTP hardware clock user space API

		The class driver also creates a character device for each
		registered clock. User space can use an open file descriptor from
		the character device as a POSIX clock id and may call
		clock_gettime, clock_settime, and clock_adjtime. These calls
		implement the basic clock operations.

		User space programs may control the clock using standardized
		ioctls. A program may query, enable, configure, and disable the
		ancillary clock features. User space can receive time stamped
		events via blocking read() and poll(). One shot and periodic
		signals may be configured via the POSIX timer_settime() system
		call.

		** Writing clock drivers

		Clock drivers include include/linux/ptp_clock_kernel.h and register
		themselves by presenting a 'struct ptp_clock_info' to the
		registration method. Clock drivers must implement all of the
		functions in the interface. If a clock does not offer a particular
		ancillary feature, then the driver should just return -EOPNOTSUPP
		from those functions.

		Drivers must ensure that all of the methods in interface are
		reentrant. Since most hardware implementations treat the time value
		as a 64 bit integer accessed as two 32 bit registers, drivers
		should use spin_lock_irqsave/spin_unlock_irqrestore to protect
		against concurrent access. This locking cannot be accomplished in
		class driver, since the lock may also be needed by the clock
		driver's interrupt service routine.

		** Supported hardware

		+ Freescale eTSEC gianfar
		- 2 Time stamp external triggers, programmable polarity (opt. interrupt)
		- 2 Alarm registers (optional interrupt)
		- 3 Periodic signals (optional interrupt)

		+ National DP83640
		- 6 GPIOs programmable as inputs or outputs
		- 6 GPIOs with dedicated functions (LED/JTAG/clock) can also be
		used as general inputs or outputs
		- GPIO inputs can time stamp external triggers
		- GPIO outputs can produce periodic signals
		- 1 interrupt pin

		+ Intel IXP465
		- Auxiliary Slave/Master Mode Snapshot (optional interrupt)
		- Target Time (optional interrupt)

Documentation/ptp/testptp.c

0 → 100644

+381 −0

Original line number	Diff line number	Diff line
		/*
		* PTP 1588 clock support - User space test program
		*
		* Copyright (C) 2010 OMICRON electronics GmbH
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or
		* (at your option) any later version.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write to the Free Software
		* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		*/
		#include <errno.h>
		#include <fcntl.h>
		#include <math.h>
		#include <signal.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/ioctl.h>
		#include <sys/mman.h>
		#include <sys/stat.h>
		#include <sys/time.h>
		#include <sys/timex.h>
		#include <sys/types.h>
		#include <time.h>
		#include <unistd.h>

		#include <linux/ptp_clock.h>

		#define DEVICE "/dev/ptp0"

		#ifndef ADJ_SETOFFSET
		#define ADJ_SETOFFSET 0x0100
		#endif

		#ifndef CLOCK_INVALID
		#define CLOCK_INVALID -1
		#endif

		/* When glibc offers the syscall, this will go away. */
		#include <sys/syscall.h>
		static int clock_adjtime(clockid_t id, struct timex *tx)
		{
		return syscall(__NR_clock_adjtime, id, tx);
		}

		static clockid_t get_clockid(int fd)
		{
		#define CLOCKFD 3
		#define FD_TO_CLOCKID(fd) ((~(clockid_t) (fd) << 3) \| CLOCKFD)

		return FD_TO_CLOCKID(fd);
		}

		static void handle_alarm(int s)
		{
		printf("received signal %d\n", s);
		}

		static int install_handler(int signum, void (*handler)(int))
		{
		struct sigaction action;
		sigset_t mask;

		/* Unblock the signal. */
		sigemptyset(&mask);
		sigaddset(&mask, signum);
		sigprocmask(SIG_UNBLOCK, &mask, NULL);

		/* Install the signal handler. */
		action.sa_handler = handler;
		action.sa_flags = 0;
		sigemptyset(&action.sa_mask);
		sigaction(signum, &action, NULL);

		return 0;
		}

		static long ppb_to_scaled_ppm(int ppb)
		{
		/*
		* The 'freq' field in the 'struct timex' is in parts per
		* million, but with a 16 bit binary fractional field.
		* Instead of calculating either one of
		*
		* scaled_ppm = (ppb / 1000) << 16 [1]
		* scaled_ppm = (ppb << 16) / 1000 [2]
		*
		* we simply use double precision math, in order to avoid the
		* truncation in [1] and the possible overflow in [2].
		*/
		return (long) (ppb * 65.536);
		}

		static void usage(char *progname)
		{
		fprintf(stderr,
		"usage: %s [options]\n"
		" -a val request a one-shot alarm after 'val' seconds\n"
		" -A val request a periodic alarm every 'val' seconds\n"
		" -c query the ptp clock's capabilities\n"
		" -d name device to open\n"
		" -e val read 'val' external time stamp events\n"
		" -f val adjust the ptp clock frequency by 'val' ppb\n"
		" -g get the ptp clock time\n"
		" -h prints this message\n"
		" -p val enable output with a period of 'val' nanoseconds\n"
		" -P val enable or disable (val=1\|0) the system clock PPS\n"
		" -s set the ptp clock time from the system time\n"
		" -S set the system time from the ptp clock time\n"
		" -t val shift the ptp clock time by 'val' seconds\n",
		progname);
		}

		int main(int argc, char *argv[])
		{
		struct ptp_clock_caps caps;
		struct ptp_extts_event event;
		struct ptp_extts_request extts_request;
		struct ptp_perout_request perout_request;
		struct timespec ts;
		struct timex tx;

		static timer_t timerid;
		struct itimerspec timeout;
		struct sigevent sigevent;

		char *progname;
		int c, cnt, fd;

		char *device = DEVICE;
		clockid_t clkid;
		int adjfreq = 0x7fffffff;
		int adjtime = 0;
		int capabilities = 0;
		int extts = 0;
		int gettime = 0;
		int oneshot = 0;
		int periodic = 0;
		int perout = -1;
		int pps = -1;
		int settime = 0;

		progname = strrchr(argv[0], '/');
		progname = progname ? 1+progname : argv[0];
		while (EOF != (c = getopt(argc, argv, "a:A:cd:e:f:ghp:P:sSt:v"))) {
		switch (c) {
		case 'a':
		oneshot = atoi(optarg);
		break;
		case 'A':
		periodic = atoi(optarg);
		break;
		case 'c':
		capabilities = 1;
		break;
		case 'd':
		device = optarg;
		break;
		case 'e':
		extts = atoi(optarg);
		break;
		case 'f':
		adjfreq = atoi(optarg);
		break;
		case 'g':
		gettime = 1;
		break;
		case 'p':
		perout = atoi(optarg);
		break;
		case 'P':
		pps = atoi(optarg);
		break;
		case 's':
		settime = 1;
		break;
		case 'S':
		settime = 2;
		break;
		case 't':
		adjtime = atoi(optarg);
		break;
		case 'h':
		usage(progname);
		return 0;
		case '?':
		default:
		usage(progname);
		return -1;
		}
		}

		fd = open(device, O_RDWR);
		if (fd < 0) {
		fprintf(stderr, "opening %s: %s\n", device, strerror(errno));
		return -1;
		}

		clkid = get_clockid(fd);
		if (CLOCK_INVALID == clkid) {
		fprintf(stderr, "failed to read clock id\n");
		return -1;
		}

		if (capabilities) {
		if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) {
		perror("PTP_CLOCK_GETCAPS");
		} else {
		printf("capabilities:\n"
		" %d maximum frequency adjustment (ppb)\n"
		" %d programmable alarms\n"
		" %d external time stamp channels\n"
		" %d programmable periodic signals\n"
		" %d pulse per second\n",
		caps.max_adj,
		caps.n_alarm,
		caps.n_ext_ts,
		caps.n_per_out,
		caps.pps);
		}
		}

		if (0x7fffffff != adjfreq) {
		memset(&tx, 0, sizeof(tx));
		tx.modes = ADJ_FREQUENCY;
		tx.freq = ppb_to_scaled_ppm(adjfreq);
		if (clock_adjtime(clkid, &tx)) {
		perror("clock_adjtime");
		} else {
		puts("frequency adjustment okay");
		}
		}

		if (adjtime) {
		memset(&tx, 0, sizeof(tx));
		tx.modes = ADJ_SETOFFSET;
		tx.time.tv_sec = adjtime;
		tx.time.tv_usec = 0;
		if (clock_adjtime(clkid, &tx) < 0) {
		perror("clock_adjtime");
		} else {
		puts("time shift okay");
		}
		}

		if (gettime) {
		if (clock_gettime(clkid, &ts)) {
		perror("clock_gettime");
		} else {
		printf("clock time: %ld.%09ld or %s",
		ts.tv_sec, ts.tv_nsec, ctime(&ts.tv_sec));
		}
		}

		if (settime == 1) {
		clock_gettime(CLOCK_REALTIME, &ts);
		if (clock_settime(clkid, &ts)) {
		perror("clock_settime");
		} else {
		puts("set time okay");
		}
		}

		if (settime == 2) {
		clock_gettime(clkid, &ts);
		if (clock_settime(CLOCK_REALTIME, &ts)) {
		perror("clock_settime");
		} else {
		puts("set time okay");
		}
		}

		if (extts) {
		memset(&extts_request, 0, sizeof(extts_request));
		extts_request.index = 0;
		extts_request.flags = PTP_ENABLE_FEATURE;
		if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
		perror("PTP_EXTTS_REQUEST");
		extts = 0;
		} else {
		puts("external time stamp request okay");
		}
		for (; extts; extts--) {
		cnt = read(fd, &event, sizeof(event));
		if (cnt != sizeof(event)) {
		perror("read");
		break;
		}
		printf("event index %u at %lld.%09u\n", event.index,
		event.t.sec, event.t.nsec);
		fflush(stdout);
		}
		/* Disable the feature again. */
		extts_request.flags = 0;
		if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
		perror("PTP_EXTTS_REQUEST");
		}
		}

		if (oneshot) {
		install_handler(SIGALRM, handle_alarm);
		/* Create a timer. */
		sigevent.sigev_notify = SIGEV_SIGNAL;
		sigevent.sigev_signo = SIGALRM;
		if (timer_create(clkid, &sigevent, &timerid)) {
		perror("timer_create");
		return -1;
		}
		/* Start the timer. */
		memset(&timeout, 0, sizeof(timeout));
		timeout.it_value.tv_sec = oneshot;
		if (timer_settime(timerid, 0, &timeout, NULL)) {
		perror("timer_settime");
		return -1;
		}
		pause();
		timer_delete(timerid);
		}

		if (periodic) {
		install_handler(SIGALRM, handle_alarm);
		/* Create a timer. */
		sigevent.sigev_notify = SIGEV_SIGNAL;
		sigevent.sigev_signo = SIGALRM;
		if (timer_create(clkid, &sigevent, &timerid)) {
		perror("timer_create");
		return -1;
		}
		/* Start the timer. */
		memset(&timeout, 0, sizeof(timeout));
		timeout.it_interval.tv_sec = periodic;
		timeout.it_value.tv_sec = periodic;
		if (timer_settime(timerid, 0, &timeout, NULL)) {
		perror("timer_settime");
		return -1;
		}
		while (1) {
		pause();
		}
		timer_delete(timerid);
		}

		if (perout >= 0) {
		if (clock_gettime(clkid, &ts)) {
		perror("clock_gettime");
		return -1;
		}
		memset(&perout_request, 0, sizeof(perout_request));
		perout_request.index = 0;
		perout_request.start.sec = ts.tv_sec + 2;
		perout_request.start.nsec = 0;
		perout_request.period.sec = 0;
		perout_request.period.nsec = perout;
		if (ioctl(fd, PTP_PEROUT_REQUEST, &perout_request)) {
		perror("PTP_PEROUT_REQUEST");
		} else {
		puts("periodic output request okay");
		}
		}

		if (pps != -1) {
		int enable = pps ? 1 : 0;
		if (ioctl(fd, PTP_ENABLE_PPS, enable)) {
		perror("PTP_ENABLE_PPS");
		} else {
		puts("pps for system time request okay");
		}
		}

		close(fd);
		return 0;
		}

Documentation/ptp/testptp.mk

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		# PTP 1588 clock support - User space test program
		#
		# Copyright (C) 2010 OMICRON electronics GmbH
		#
		# This program is free software; you can redistribute it and/or modify
		# it under the terms of the GNU General Public License as published by
		# the Free Software Foundation; either version 2 of the License, or
		# (at your option) any later version.
		#
		# This program is distributed in the hope that it will be useful,
		# but WITHOUT ANY WARRANTY; without even the implied warranty of
		# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		# GNU General Public License for more details.
		#
		# You should have received a copy of the GNU General Public License
		# along with this program; if not, write to the Free Software
		# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

		CC = $(CROSS_COMPILE)gcc
		INC = -I$(KBUILD_OUTPUT)/usr/include
		CFLAGS = -Wall $(INC)
		LDLIBS = -lrt
		PROGS = testptp

		all: $(PROGS)

		testptp: testptp.o

		clean:
		rm -f testptp.o

		distclean: clean
		rm -f $(PROGS)

drivers/Kconfig

+2 −0

Original line number	Diff line number	Diff line
		@@ -54,6 +54,8 @@ source "drivers/spi/Kconfig"

		source "drivers/pps/Kconfig"

		source "drivers/ptp/Kconfig"

		source "drivers/gpio/Kconfig"

		source "drivers/w1/Kconfig"