* [PATCH] LinuxPPS - definitive version
@ 2007-07-17 18:05 Rodolfo Giometti
2007-07-23 13:35 ` David Woodhouse
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-17 18:05 UTC (permalink / raw)
To: linux-kernel; +Cc: Andrew Morton, David Woodhouse
[-- Attachment #1: Type: text/plain, Size: 423 bytes --]
Hello,
here my last patch for PPS support.
In my opinion it should be ok for inclusion... please, let me know if
something should be still changed.
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
[-- Attachment #2: ntp-pps-2.6.22.diff --]
[-- Type: text/x-diff, Size: 68442 bytes --]
diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
new file mode 100644
index 0000000..a2660a2
--- /dev/null
+++ b/Documentation/pps/Makefile
@@ -0,0 +1,27 @@
+TARGETS = ppstest ppsctl
+
+CFLAGS += -Wall -O2 -D_GNU_SOURCE
+CFLAGS += -I .
+CFLAGS += -ggdb
+
+# -- Actions section ----------------------------------------------------------
+
+.PHONY : all depend dep
+
+all : .depend $(TARGETS)
+
+.depend depend dep :
+ $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
+
+
+# -- Clean section ------------------------------------------------------------
+
+.PHONY : clean
+
+clean :
+ rm -f *.o *~ core .depend
+ rm -f ${TARGETS}
diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
new file mode 100644
index 0000000..0617ea4
--- /dev/null
+++ b/Documentation/pps/pps.txt
@@ -0,0 +1,211 @@
+
+ PPS - Pulse Per Second
+ ----------------------
+
+(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com>
+
+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.
+
+
+
+Overview
+--------
+
+LinuxPPS provides a programming interface (API) to define into the
+system several PPS sources.
+
+PPS means "pulse per second" and a PPS source is just a device which
+provides a high precision signal each second so that an application
+can use it to adjust system clock time.
+
+A PPS source can be connected to a serial port (usually to the Data
+Carrier Detect pin) or to a parallel port (ACK-pin) or to a special
+CPU's GPIOs (this is the common case in embedded systems) but in each
+case when a new pulse comes the system must apply to it a timestamp
+and record it for the userland.
+
+Common use is the combination of the NTPD as userland program with a
+GPS receiver as PPS source to obtain a wallclock-time with
+sub-millisecond synchronisation to UTC.
+
+
+RFC considerations
+------------------
+
+While implementing a PPS API as RFC 2783 defines and using an embedded
+CPU GPIO-Pin as physical link to the signal, I encountered a deeper
+problem:
+
+ At startup it needs a file descriptor as argument for the function
+ time_pps_create().
+
+This implies that the source has a /dev/... entry. This assumption is
+ok for the serial and parallel port, where you can do something
+useful besides(!) the gathering of timestamps as it is the central
+task for a PPS-API. But this assumption does not work for a single
+purpose GPIO line. In this case even basic file-related functionality
+(like read() and write()) makes no sense at all and should not be a
+precondition for the use of a PPS-API.
+
+The problem can be simply solved if you change the original RFC 2783:
+
+ pps_handle_t type is an opaque __scalar type__ used to represent a
+ PPS source within the API
+
+into a modified:
+
+ pps_handle_t type is an opaque __variable__ used to represent a PPS
+ source within the API and programs should not access it directly to
+ it due to its opacity.
+
+This change seems to be neglibile because even the original RFC 2783
+does not encourage programs to check (read: use) the pps_handle_t
+variable before calling the time_pps_*() functions, since each
+function should do this job internally.
+
+If I intentionally separate the concept of "file descriptor" from the
+concept of the "PPS source" I'm obliged to provide a solution to find
+and register a PPS-source without using a file descriptor: it's done
+by the functions time_pps_findsource() and time_pps_findpath() now.
+
+According to this current NTPD drivers' code should be modified as
+follows:
+
++#ifdef PPS_HAVE_FINDPATH
++ /* Get the PPS source's real name */
++ fd = readlink(link, path, STRING_LEN-1);
++ if (fd <= 0)
++ strncpy(path, link, STRING_LEN);
++ else
++ path[fd] = '\0';
++
++ /* Try to find the source */
++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
++ if (fd < 0) {
++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" "
++ "in the system", path);
++ return 1;
++ }
++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"",
++ fd, path, id);
++#endif /* PPS_HAVE_FINDPATH */
++
++
+ if (time_pps_create(fd, &pps_handle) < 0) {
+- pps_handle = 0;
+ msyslog(LOG_ERR, "refclock: time_pps_create failed: %m");
+ }
+
+
+Coding example
+--------------
+
+To register a PPS source into the kernel you should define a struct
+pps_source_info_s as follow:
+
+ static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+ };
+
+and then calling the function pps_register_source() in your
+intialization routine as follow:
+
+ source = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+
+The pps_register_source() prototype is:
+
+ int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+
+where "info" is a pointer to a structure that describes a particular
+PPS source, "default_params" tells the system what the initial default
+parameters for the device should be (is obvious that these parameters
+must be a subset of ones defined into the struct
+pps_source_info_s which describe the capabilities of the driver)
+and "try_id" can be used to force a particular ID for your device into
+the system (just use -1 if you wish the system chooses one for you).
+
+Once you have registered a new PPS source into the system you can
+signal an assert event (for example in the interrupt handler routine)
+just using:
+
+ pps_event(source, PPS_CAPTUREASSERT, ptr);
+
+The same function may also run the defined echo function
+(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user
+asked for that... etc..
+
+Please see the file drivers/pps/clients/ktimer.c for an example code.
+
+
+SYSFS support
+-------------
+
+The SYSFS support is enabled by default if the SYSFS filesystem is
+enabled in the kernel and it provides a new class:
+
+ $ ls /sys/class/pps/
+ 00/ 01/ 02/
+
+Every directory is the ID of a PPS sources defined into the system and
+inside you find several files:
+
+ $ ls /sys/class/pps/00/
+ assert clear echo mode name path subsystem@ uevent
+
+Inside each "assert" and "clear" file you can find the timestamp and a
+sequence number:
+
+ $ cat /sys/class/pps/00/assert
+ 1170026870.983207967#8
+
+Where before the "#" is the timestamp in seconds and after it is the
+sequence number. Other files are:
+
+* echo: reports if the PPS source has an echo function or not;
+
+* mode: reports available PPS functioning modes;
+
+* name: reports the PPS source's name;
+
+* path: reports the PPS source's device path, that is the device the
+ PPS source is connected to (if it exists).
+
+
+Testing the PPS support
+-----------------------
+
+In order to test the PPS support even without specific hardware you can use
+the ktimer driver (see the client subsection in the PPS configuration menu)
+and the userland tools provided into Documentaion/pps/ directory.
+
+Once you have enabled the compilation of ktimer just modprobe it (if
+not statically compiled):
+
+ # modprobe ktimer
+
+and the run ppstest as follow:
+
+ $ ./ppstest
+ found PPS source #0 "ktimer" on ""
+ ok, found 1 source(s), now start fetching data...
+ source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0
+ source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0
+
+Please, note that to compile userland programs you need the file timepps.h
+(see Documentaion/pps/).
\ No newline at end of file
diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c
new file mode 100644
index 0000000..e6ab2b9
--- /dev/null
+++ b/Documentation/pps/ppsctl.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/serial.h>
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);
+
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd, ret;
+ struct serial_struct ss;
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0) {
+ perror("open");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCGSERIAL, &ss);
+ if (ret < 0 ) {
+ perror("ioctl(TIOCGSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ if (argc < 3) { /* just read PPS status */
+ printf("PPS is %sabled\n",
+ ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");
+ exit(EXIT_SUCCESS);
+ }
+
+ if (argv[2][0] == 'e' || argv[2][0] == '1')
+ ss.flags |= ASYNC_HARDPPS_CD;
+ else if (argv[2][0] == 'd' || argv[2][0] == '0')
+ ss.flags &= ~ASYNC_HARDPPS_CD;
+ else {
+ fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCSSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCSSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
new file mode 100644
index 0000000..efbe28f
--- /dev/null
+++ b/Documentation/pps/ppstest.c
@@ -0,0 +1,199 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <timepps.h>
+
+#define STRING_LEN PPS_MAX_NAME_LEN
+
+int find_source(int try_link, char *link, pps_handle_t *handle, int *avail_mode)
+{
+ int num = -1;
+ char id[STRING_LEN] = "", /* no ID string by default */
+ path[STRING_LEN];
+ pps_params_t params;
+ int ret;
+
+ if (try_link) {
+ printf("trying PPS source \"%s\"\n", link);
+#ifdef PPS_HAVE_FINDPATH
+ /* Get the PPS source's real name */
+ time_pps_readlink(link, STRING_LEN, path, STRING_LEN);
+
+ /* Try to find the source by using the supplied "path" name */
+ ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
+ if (ret < 0)
+ goto exit;
+ num = ret;
+#else
+#warning "cannot use time_pps_findpath()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDPATH */
+ }
+
+#ifdef PPS_HAVE_FINDSOURCE
+ /* Try to find the source (by using "index = -1" we ask just
+ * for a generic source) */
+ ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN);
+#else
+#warning "cannot use time_pps_findsource()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDSOURCE */
+ if (ret < 0) {
+exit:
+ fprintf(stderr, "no available PPS source in the system\n");
+ return -1;
+ }
+ num = ret;
+ printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path);
+
+ /* If "path" is not NULL we should *at least* open the pointed
+ * device in order to enable the interrupts generation.
+ * Note that this can be NOT enough anyway, infact you may need sending
+ * additional commands to your GPS antenna before it starts sending
+ * the PPS signal. */
+ if (strlen(path)) {
+ ret = open(path, O_RDWR);
+ if (ret < 0) {
+ fprintf(stderr, "cannot open \"%s\" (%m)\n", path);
+ return -1;
+ }
+ }
+
+ /* Open the PPS source */
+ ret = time_pps_create(num, handle);
+ if (ret < 0) {
+ fprintf(stderr, "cannot create a PPS source (%m)\n");
+ return -1;
+ }
+
+ /* Find out what features are supported */
+ ret = time_pps_getcap(*handle, avail_mode);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get capabilities (%m)\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
+ fprintf(stderr, "cannot CAPTUREASSERT\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_OFFSETASSERT) == 0) {
+ fprintf(stderr, "cannot OFFSETASSERT\n");
+ return -1;
+ }
+
+ /* Capture assert timestamps, and compensate for a 675 nsec
+ * propagation delay */
+ ret = time_pps_getparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get parameters (%m)\n");
+ return -1;
+ }
+ params.assert_offset.tv_sec = 0;
+ params.assert_offset.tv_nsec = 675;
+ params.mode |= PPS_CAPTUREASSERT|PPS_OFFSETASSERT;
+ ret = time_pps_setparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot set parameters (%m)\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fetch_source(int i, pps_handle_t *handle, int *avail_mode)
+{
+ struct timespec timeout;
+ pps_info_t infobuf;
+ int ret;
+
+ /* create a zero-valued timeout */
+ timeout.tv_sec = 3;
+ timeout.tv_nsec = 0;
+
+retry :
+ if (*avail_mode&PPS_CANWAIT) {
+ /* waits for the next event */
+ ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout);
+ }
+ else {
+ sleep(1);
+ ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout);
+ }
+ if (ret < 0) {
+ if (ret == -EINTR) {
+ fprintf(stderr, "time_pps_fetch() got a signal!\n");
+ goto retry;
+ }
+
+ fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);
+ return -1;
+ }
+
+ printf("source %d - "
+ "assert %ld.%09ld, sequence: %ld - "
+ "clear %ld.%09ld, sequence: %ld\n",
+ i,
+ infobuf.assert_timestamp.tv_sec,
+ infobuf.assert_timestamp.tv_nsec,
+ infobuf.assert_sequence,
+ infobuf.clear_timestamp.tv_sec,
+ infobuf.clear_timestamp.tv_nsec,
+ infobuf.clear_sequence);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ int num,
+ try_link = 0; /* by default use findsource */
+ char link[STRING_LEN] = "/dev/gps0"; /* just a default device */
+ pps_handle_t handle[4];
+ int avail_mode[4];
+ int i = 0, ret;
+
+ if (argc == 1) {
+ ret = find_source(try_link, link, &handle[0], &avail_mode[0]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+
+ num = 1;
+ }
+ else {
+ for (i = 1; i < argc && i <= 4; i++) {
+ ret = sscanf(argv[i], "%d", &num);
+ if (ret < 1) {
+ try_link = ~0;
+ strncpy(link, argv[i], STRING_LEN);
+ }
+
+ ret = find_source(try_link, link, &handle[i-1], &avail_mode[i-1]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+ }
+
+ num = i-1;
+ }
+
+ printf("ok, found %d source(s), now start fetching data...\n", num);
+
+ /* loop, printing the most recent timestamp every second or so */
+ while (1) {
+ for (i = 0; i < num; i++) {
+ ret = fetch_source(i, &handle[i], &avail_mode[i]);
+ if (ret < 0 && errno != ETIMEDOUT)
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ for (; i >= 0; i--)
+ time_pps_destroy(handle[i]);
+
+ return 0;
+}
diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
new file mode 100644
index 0000000..86850a1
--- /dev/null
+++ b/Documentation/pps/timepps.h
@@ -0,0 +1,236 @@
+/*
+ * timepps.h -- PPS API main header
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+#ifndef _SYS_TIMEPPS_H_
+#define _SYS_TIMEPPS_H_
+
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <errno.h>
+#include <linux/pps.h>
+
+/*
+ * New data structures
+ */
+
+struct ntp_fp {
+ unsigned int integral;
+ unsigned int fractional;
+};
+
+union pps_timeu {
+ struct timespec tspec;
+ struct ntp_fp ntpfp;
+ unsigned long longpad[3];
+};
+
+struct pps_info {
+ unsigned long assert_sequence; /* seq. num. of assert event */
+ unsigned long clear_sequence; /* seq. num. of clear event */
+ union pps_timeu assert_tu; /* time of assert event */
+ union pps_timeu clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_params {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ union pps_timeu assert_off_tu; /* offset compensation for assert */
+ union pps_timeu clear_off_tu; /* offset compensation for clear */
+};
+
+typedef int pps_handle_t; /* represents a PPS source */
+typedef unsigned long pps_seq_t; /* sequence number */
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
+typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */
+typedef struct pps_info pps_info_t;
+typedef struct pps_params pps_params_t;
+
+#define assert_timestamp assert_tu.tspec
+#define clear_timestamp clear_tu.tspec
+
+#define assert_timestamp_ntpfp assert_tu.ntpfp
+#define clear_timestamp_ntpfp clear_tu.ntpfp
+
+#define assert_offset assert_off_tu.tspec
+#define clear_offset clear_off_tu.tspec
+
+#define assert_offset_ntpfp assert_off_tu.ntpfp
+#define clear_offset_ntpfp clear_off_tu.ntpfp
+
+/*
+ * The PPS API
+ */
+
+#define PPS_HAVE_FINDSOURCE 1
+#define pps_min(a, b) (a) < (b) ? a : b
+int time_pps_findsource(int index, char *path, int pathlen, char *idstring, int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ data.source = index;
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+ strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+/* Defined iff PPS_HAVE_FINDPATH is defined */
+void time_pps_readlink(char *link, int linklen, char *path, int pathlen)
+{
+ int i;
+
+ i = readlink(link, path, pathlen - 1);
+ if (i <= 0) {
+ /* "link" is not a valid symbolic so we directly use it */
+ strncpy(path, link, linklen <= pathlen ? linklen : pathlen);
+ return;
+ }
+
+ /* Return the file name where "link" points to */
+ path[i] = '\0';
+}
+
+#define PPS_HAVE_FINDPATH 1
+int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+int time_pps_create(int source, pps_handle_t *handle)
+{
+ if (!handle) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* In LinuxPPS there are no differences between a PPS source and
+ * a PPS handle so we return the same value.
+ */
+ *handle = source;
+
+ return 0;
+}
+
+int time_pps_destroy(pps_handle_t handle)
+{
+ /* Nothing to destroy here */
+
+ return 0;
+}
+
+int time_pps_getparams(pps_handle_t handle,
+ pps_params_t *ppsparams)
+{
+ int ret;
+ struct pps_kparams __ppsparams;
+
+ ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+
+ ppsparams->api_version = __ppsparams.api_version;
+ ppsparams->mode = __ppsparams.mode;
+ ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;
+ ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;
+ ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;
+ ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;
+
+ return ret;
+}
+
+int time_pps_setparams(pps_handle_t handle,
+ const pps_params_t *ppsparams)
+{
+ struct pps_kparams __ppsparams;
+
+ __ppsparams.api_version = ppsparams->api_version;
+ __ppsparams.mode = ppsparams->mode;
+ __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;
+ __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;
+ __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;
+ __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;
+
+ return syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+}
+
+/* Get capabilities for handle */
+int time_pps_getcap(pps_handle_t handle, int *mode)
+{
+ return syscall(__NR_time_pps_getcap, handle, mode);
+}
+
+int time_pps_fetch(pps_handle_t handle, const int tsformat,
+ pps_info_t *ppsinfobuf,
+ const struct timespec *timeout)
+{
+ struct pps_kinfo __ppsinfobuf;
+ struct pps_ktime __timeout;
+ int ret;
+
+ /* Sanity checks */
+ if (tsformat != PPS_TSFMT_TSPEC) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (timeout) {
+ __timeout.sec = timeout->tv_sec;
+ __timeout.nsec = timeout->tv_nsec;
+ }
+
+ ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf,
+ timeout ? &__timeout : NULL);
+
+ ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence;
+ ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence;
+ ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec;
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec;
+ ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec;
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec;
+ ppsinfobuf->current_mode = __ppsinfobuf.current_mode;
+
+ return ret;
+}
+
+int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
+ const int edge, const int tsformat)
+{
+ /* LinuxPPS doesn't implement kernel consumer feature */
+ errno = EOPNOTSUPP;
+ return -1;
+}
+
+#endif /* _SYS_TIMEPPS_H_ */
diff --git a/MAINTAINERS b/MAINTAINERS
index df40a4e..17e9a02 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2903,6 +2903,13 @@ P: Michal Ostrowski
M: mostrows@speakeasy.net
S: Maintained
+PPS SUPPORT
+P: Rodolfo Giometti
+M: giometti@enneenne.com
+W: http://wiki.enneenne.com/index.php/LinuxPPS_support
+L: linuxpps@ml.enneenne.com
+S: Maintained
+
PREEMPTIBLE KERNEL
P: Robert Love
M: rml@tech9.net
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index bf6adce..f1bf4ff 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -323,3 +323,8 @@ ENTRY(sys_call_table)
.long sys_signalfd
.long sys_timerfd
.long sys_eventfd
+ .long sys_time_pps_cmd
+ .long sys_time_pps_getparams /* 325 */
+ .long sys_time_pps_setparams
+ .long sys_time_pps_getcap
+ .long sys_time_pps_fetch
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 050323f..bb54cab 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
source "drivers/spi/Kconfig"
+source "drivers/pps/Kconfig"
+
source "drivers/w1/Kconfig"
source "drivers/hwmon/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index adad2f3..985d495 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/
obj-$(CONFIG_I2O) += message/
obj-$(CONFIG_RTC_LIB) += rtc/
obj-y += i2c/
+obj-$(CONFIG_PPS) += pps/
obj-$(CONFIG_W1) += w1/
obj-$(CONFIG_HWMON) += hwmon/
obj-$(CONFIG_PHONE) += telephony/
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 62051f8..a50b336 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -746,6 +746,27 @@ static struct console lpcons = {
#endif /* console on line printer */
+/* Support for PPS signal on the line printer */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+
+static void lp_pps_echo(int source, int event, void *data)
+{
+ struct parport *port = data;
+ unsigned char status = parport_read_status(port);
+
+ /* echo event via SEL bit */
+ parport_write_control(port,
+ parport_read_control(port) | PARPORT_CONTROL_SELECT);
+
+ /* signal no event */
+ if ((status & PARPORT_STATUS_ACK) != 0)
+ parport_write_control(port,
+ parport_read_control(port) & ~PARPORT_CONTROL_SELECT);
+}
+
+#endif
+
/* --- initialisation code ------------------------------------- */
static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
@@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port)
}
#endif
+#ifdef CONFIG_PPS_CLIENT_LP
+ snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr);
+
+ /* No PPS support if lp port has no IRQ line */
+ if (port->irq != PARPORT_IRQ_NONE) {
+ strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN);
+
+ port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ port->pps_info.echo = lp_pps_echo;
+
+ port->pps_source = pps_register_source(&(port->pps_info),
+ PPS_CAPTUREASSERT | PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (port->pps_source < 0)
+ pps_err("cannot register PPS source \"%s\"",
+ port->pps_info.path);
+ else
+ pps_info("PPS source #%d \"%s\" added to the system",
+ port->pps_source, port->pps_info.path);
+ } else {
+ port->pps_source = -1;
+ pps_err("PPS support disabled due port \"%s\" is in polling mode",
+ port->pps_info.path);
+ }
+#endif
+
return 0;
}
@@ -860,6 +910,14 @@ static void lp_detach (struct parport *port)
console_registered = NULL;
}
#endif /* CONFIG_LP_CONSOLE */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ if (port->pps_source >= 0) {
+ pps_unregister_source(&(port->pps_info));
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, port->pps_info.path);
+ }
+#endif
}
static struct parport_driver lp_driver = {
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 0000000..1d16f14
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,34 @@
+#
+# Character device configuration
+#
+
+menu "PPS support"
+
+config PPS
+ bool "PPS support"
+ depends on EXPERIMENTAL
+ ---help---
+ PPS (Pulse Per Second) is a special pulse provided by some GPS
+ antennae. Userland can use it to get an high time reference.
+
+ Some antennae's PPS signals are connected with the CD (Carrier
+ Detect) pin of the serial line they use to communicate with the
+ host. In this case use the SERIAL_LINE client support.
+
+ Some antennae's PPS signals are connected with some special host
+ inputs so you have to enable the corresponding client support.
+
+ This PPS support can also be built as a module. If so, the module
+ will be called pps-core.
+
+config PPS_DEBUG
+ bool "PPS debugging messages"
+ depends on PPS
+ help
+ Say Y here if you want the PPS support to produce a bunch of debug
+ messages to the system log. Select this if you are having a
+ problem with PPS support and want to see more of what is going on.
+
+source drivers/pps/clients/Kconfig
+
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 0000000..76101cd
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the PPS core.
+#
+
+pps_core-objs += pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS) += pps_core.o
+obj-y += clients/
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 0000000..867df3a
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,30 @@
+#
+# LinuxPPS clients configuration
+#
+
+if PPS
+
+comment "PPS clients support"
+
+config PPS_CLIENT_KTIMER
+ tristate "Kernel timer client (Testing client, use for debug)"
+ help
+ If you say yes here you get support for a PPS debugging client
+ which uses a kernel timer to generate the PPS signal.
+
+ This driver can also be built as a module. If so, the module
+ will be called ktimer.o.
+
+config PPS_CLIENT_UART
+ bool "UART serial support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the CD (Carrier Detect) pin of your serial port.
+
+config PPS_CLIENT_LP
+ bool "Parallel printer support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the interrupt pin of your parallel port.
+
+endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
new file mode 100644
index 0000000..3ecca41
--- /dev/null
+++ b/drivers/pps/clients/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for miscellaneous I2C chip drivers.
+#
+
+obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
+
diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c
new file mode 100644
index 0000000..e9e5c47
--- /dev/null
+++ b/drivers/pps/clients/ktimer.c
@@ -0,0 +1,113 @@
+/*
+ * ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+
+#include <linux/pps.h>
+
+/*
+ * Global variables
+ */
+
+static int source;
+static struct timer_list ktimer;
+
+/*
+ * The kernel timer
+ */
+
+static void pps_ktimer_event(unsigned long ptr)
+{
+ pps_info("PPS event at %lu", jiffies);
+
+ pps_event(source, PPS_CAPTUREASSERT, NULL);
+
+ mod_timer(&ktimer, jiffies + HZ);
+}
+
+/*
+ * The echo function
+ */
+
+static void pps_ktimer_echo(int source, int event, void *data)
+{
+ pps_info("echo %s %s for source %d",
+ event & PPS_CAPTUREASSERT ? "assert" : "",
+ event & PPS_CAPTURECLEAR ? "clear" : "",
+ source);
+}
+
+/*
+ * The PPS info struct
+ */
+
+static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT|PPS_OFFSETASSERT|PPS_ECHOASSERT| \
+ PPS_CANWAIT|PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+ del_timer_sync(&ktimer);
+ pps_unregister_source(&pps_ktimer_info);
+
+ pps_info("ktimer PPS source unregistered");
+}
+
+static int __init pps_ktimer_init(void)
+{
+ int ret;
+
+ ret = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register ktimer source");
+ return ret;
+ }
+ source = ret;
+
+ setup_timer(&ktimer, pps_ktimer_event, 0);
+ mod_timer(&ktimer, jiffies + HZ);
+
+ pps_info("ktimer PPS source registered at %d", source);
+
+ return 0;
+}
+
+module_init(pps_ktimer_init);
+module_exit(pps_ktimer_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("testing PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 0000000..977aa14
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,215 @@
+/*
+ * kapi.c -- kernel API
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/pps.h>
+
+/*
+ * Local functions
+ */
+
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+ ts->nsec += offset->nsec;
+ if (ts->nsec >= NSEC_PER_SEC) {
+ ts->nsec -= NSEC_PER_SEC;
+ ts->sec++;
+ } else if (ts->nsec < 0) {
+ ts->nsec += NSEC_PER_SEC;
+ ts->sec--;
+ }
+ ts->sec += offset->sec;
+}
+
+/*
+ * Exported functions
+ */
+
+int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+{
+ int i = -1, err = 0, ret;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ if (try_id >= 0) {
+ if (pps_is_allocated(try_id)) {
+ pps_err("source id %d busy", try_id);
+ err = -EBUSY;
+ goto pps_register_source_exit;
+ }
+ i = try_id;
+ } else {
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (!pps_is_allocated(i))
+ break;
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("no free source ids");
+ err = -ENOMEM;
+ goto pps_register_source_exit;
+ }
+ }
+
+ /* Sanity checks */
+ if ((info->mode & default_params) != default_params) {
+ pps_err("unsupported default parameters");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+ info->echo == NULL) {
+ pps_err("echo function is not defined");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ pps_err("unspecified time format");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+
+ /* Allocate the PPS source.
+ *
+ * Note that we should reset all fields BUT "info" one! */
+ memset(&(pps_source[i].params), 0, sizeof(struct pps_kparams));
+ pps_source[i].params.api_version = PPS_API_VERS;
+ pps_source[i].params.mode = default_params;
+ pps_source[i].assert_sequence = 0;
+ pps_source[i].clear_sequence = 0;
+ pps_source[i].current_mode = 0;
+ pps_source[i].go = 0;
+ init_waitqueue_head(&pps_source[i].queue);
+
+ /* Allocate the PPS source */
+ pps_source[i].info = info;
+
+pps_register_source_exit :
+ mutex_unlock(&pps_mutex);
+
+ if (err < 0)
+ return err;
+
+ ret = pps_sysfs_create_source_entry(info, i);
+ if (ret < 0)
+ pps_err("unable to create sysfs entry for source %d", i);
+
+ return i;
+}
+EXPORT_SYMBOL(pps_register_source);
+
+void pps_unregister_source(struct pps_source_info_s *info)
+{
+ int i;
+
+ pps_sysfs_remove_source_entry(info);
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) && pps_source[i].info == info)
+ break;
+
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("warning! Try to unregister an unknow PPS source");
+ goto pps_unregister_source_exit;
+ }
+
+ /* Deallocate the PPS source */
+ pps_source[i].info = &dummy_info;
+
+pps_unregister_source_exit :
+ mutex_unlock(&pps_mutex);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+
+void pps_event(int source, int event, void *data)
+{
+ struct timespec __ts;
+ struct pps_ktime ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&__ts);
+
+ /* ... and translate it to PPS time data struct */
+ ts.sec = __ts.tv_sec;
+ ts.nsec = __ts.tv_nsec;
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
+ pps_err("unknow event (%x) for source %d", event, source);
+ return;
+ }
+
+ /* We wish not using locks at all into this function... a possible
+ * solution is to check the "info" field against the pointer to
+ * "dummy_info".
+ * If "info" points to "dummy_info" we can return doing nothing since,
+ * even if a new PPS source is registered by another CPU we can
+ * safely not register current event.
+ * If "info" points to a valid PPS source's info data we can continue
+ * without problem since, even if current PPS source is deregistered
+ * by another CPU, we still continue writing data into a valid area
+ * (dummy_info).
+ */
+ if (pps_source[source].info == &dummy_info)
+ return;
+
+ /* Must call the echo function? */
+ if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+ pps_source[source].info->echo(source, event, data);
+
+ /* Check the event */
+ pps_source[source].current_mode = pps_source[source].params.mode;
+ if (event & PPS_CAPTUREASSERT) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETASSERT)
+ pps_add_offset(&ts,
+ &pps_source[source].params.assert_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].assert_tu = ts;
+ pps_source[source].assert_sequence++;
+ pps_dbg("capture assert seq #%u for source %d",
+ pps_source[source].assert_sequence, source);
+ }
+ if (event & PPS_CAPTURECLEAR) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETCLEAR)
+ pps_add_offset(&ts,
+ &pps_source[source].params.clear_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].clear_tu = ts;
+ pps_source[source].clear_sequence++;
+ pps_dbg("capture clear seq #%u for source %d",
+ pps_source[source].clear_sequence, source);
+ }
+
+ pps_source[source].go = ~0;
+ wake_up_interruptible(&pps_source[source].queue);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 0000000..42b5e11
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,398 @@
+/*
+ * pps.c -- Main PPS support file
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/linkage.h>
+#include <linux/sched.h>
+#include <linux/pps.h>
+#include <asm/uaccess.h>
+
+/*
+ * Global variables
+ */
+
+struct pps_s pps_source[PPS_MAX_SOURCES];
+DEFINE_MUTEX(pps_mutex);
+
+void dummy_echo(int source, int event, void *data) { }
+struct pps_source_info_s dummy_info; /* Dummy PPS info for unallocated
+ PPS sources */
+
+/*
+ * Misc functions
+ */
+
+static inline int pps_check_source(int source)
+{
+ return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0;
+}
+
+static int pps_find_source(int source)
+{
+ int i;
+
+ if (source >= 0) {
+ if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source))
+ return -EINVAL;
+ else
+ return source;
+ }
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+static int pps_find_path(char *path)
+{
+ int i;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) &&
+ (strncmp(pps_source[i].info->path, path,
+ PPS_MAX_NAME_LEN) == 0 ||
+ strncmp(pps_source[i].info->name, path,
+ PPS_MAX_NAME_LEN) == 0))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+/*
+ * PPS System Calls
+ */
+
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg)
+{
+ struct pps_source_data_s data;
+ int ret = 0;
+
+ pps_dbg("%s: cmd %d", __FUNCTION__, cmd);
+
+ /* Sanity checks */
+ if (_IOC_TYPE(cmd) != 'P')
+ return -EOPNOTSUPP;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ switch (cmd) {
+ case PPS_CMD_FIND_SRC :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source);
+
+ data.source = pps_find_source(data.source);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ case PPS_CMD_FIND_PATH :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path);
+
+ data.source = pps_find_path(data.path);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ default :
+ pps_err("invalid sys_time_pps_cmd %d", cmd);
+ ret = -EOPNOTSUPP;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ /* Found! So copy the info */
+ strncpy(data.name, pps_source[data.source].info->name,
+ PPS_MAX_NAME_LEN);
+ strncpy(data.path, pps_source[data.source].info->path,
+ PPS_MAX_NAME_LEN);
+
+ ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_cmd_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params)
+{
+ int ret = 0;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getparams_exit;
+ }
+
+ /* Return current parameters */
+ ret = copy_to_user(params, &pps_source[source].params,
+ sizeof(struct pps_kparams));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_getparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Check the capabilities */
+ if (!capable(CAP_SYS_TIME))
+ return -EPERM;
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+ if ((params->mode & ~pps_source[source].info->mode) != 0) {
+ pps_dbg("unsupported capabilities");
+ return -EINVAL;
+ }
+ if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+ pps_dbg("capture mode unspecified");
+ return -EINVAL;
+ }
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Save the new parameters */
+ ret = copy_from_user(&pps_source[source].params, params,
+ sizeof(struct pps_kparams));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Restore the read only parameters */
+ if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ /* section 3.3 of RFC 2783 interpreted */
+ pps_dbg("time format unspecified");
+ pps_source[source].params.mode |= PPS_TSFMT_TSPEC;
+ }
+ if (pps_source[source].info->mode & PPS_CANWAIT)
+ pps_source[source].params.mode |= PPS_CANWAIT;
+ pps_source[source].params.api_version = PPS_API_VERS;
+
+sys_time_pps_setparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!mode)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getcap_exit;
+ }
+
+ ret = put_user(pps_source[source].info->mode, mode);
+
+sys_time_pps_getcap_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout)
+{
+ unsigned long ticks;
+ struct pps_kinfo pi;
+ struct pps_ktime to;
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ if (!info)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ pps_source[source].go = 0;
+
+ /* Manage the timeout */
+ if (timeout) {
+ ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime));
+ if (ret) {
+ goto sys_time_pps_fetch_exit;
+ ret = -EFAULT;
+ }
+ pps_dbg("timeout %lld.%09d", to.sec, to.nsec);
+ ticks = to.sec * HZ;
+ ticks += to.nsec / (NSEC_PER_SEC / HZ);
+
+ if (ticks != 0) {
+ ret = wait_event_interruptible_timeout(
+ pps_source[source].queue,
+ pps_source[source].go, ticks);
+ if (ret == 0) {
+ pps_dbg("timeout expired");
+ ret = -ETIMEDOUT;
+ goto sys_time_pps_fetch_exit;
+ }
+ }
+ } else
+ ret = wait_event_interruptible(pps_source[source].queue,
+ pps_source[source].go);
+
+ /* Check for pending signals */
+ if (ret == -ERESTARTSYS) {
+ pps_dbg("pending signal caught");
+ ret = -EINTR;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ /* Return the fetched timestamp */
+ pi.assert_sequence = pps_source[source].assert_sequence;
+ pi.clear_sequence = pps_source[source].clear_sequence;
+ pi.assert_tu = pps_source[source].assert_tu;
+ pi.clear_tu = pps_source[source].clear_tu;
+ pi.current_mode = pps_source[source].current_mode;
+ ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_fetch_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_exit(void)
+{
+ pps_sysfs_unregister();
+
+ pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS);
+}
+
+static int __init pps_init(void)
+{
+ int i, ret;
+
+ /* Init pps_source info */
+ dummy_info.echo = dummy_echo;
+ for (i = 0; i < PPS_MAX_SOURCES; i++) {
+ pps_source[i].info = &dummy_info;
+ init_waitqueue_head(&pps_source[i].queue);
+ }
+
+ /* Register to sysfs */
+ ret = pps_sysfs_register();
+ if (ret < 0) {
+ pps_err("unable to register sysfs");
+ return ret;
+ }
+
+ pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS);
+ pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+ "<giometti@linux.it>", PPS_VERSION);
+
+ return 0;
+}
+
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
new file mode 100644
index 0000000..e52dd8e
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,217 @@
+/*
+ * sysfs.c -- sysfs support
+ *
+ *
+ * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/device.h>
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <linux/pps.h>
+
+/*
+ * Private functions
+ */
+
+static ssize_t pps_show_assert(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->assert_tu.sec, dev->assert_tu.nsec,
+ dev->assert_sequence);
+}
+
+static ssize_t pps_show_clear(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->clear_tu.sec, dev->clear_tu.nsec,
+ dev->clear_sequence);
+}
+
+static ssize_t pps_show_mode(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%4x\n", info->mode);
+}
+
+static ssize_t pps_show_echo(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%d\n", !!info->echo);
+}
+
+static ssize_t pps_show_name(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->name);
+}
+
+static ssize_t pps_show_path(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->path);
+}
+
+/*
+ * Files definitions
+ */
+
+#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \
+{ \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = _mode, \
+ .owner = THIS_MODULE, \
+ }, \
+ .show = _show, \
+ .store = _store, \
+}
+
+static struct class_device_attribute pps_class_device_attributes[] = {
+ DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL),
+ DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL),
+ DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL),
+ DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL),
+ DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL),
+ DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL),
+};
+
+/*
+ * Class definitions
+ */
+
+static void pps_class_release(struct class_device *cdev)
+{
+ /* Nop??? */
+}
+
+static struct class pps_class = {
+ .name = "pps",
+ .release = pps_class_release,
+};
+
+/*
+ * Public functions
+ */
+
+void pps_sysfs_remove_source_entry(struct pps_source_info_s *info)
+{
+ int i;
+
+ /* Sanity checks */
+ if (info == NULL)
+ return;
+
+ /* Delete info files */
+ if (info->mode&PPS_CAPTUREASSERT)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+
+ if (info->mode&PPS_CAPTURECLEAR)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ /* Deregister the pps class */
+ class_device_unregister(&info->class_dev);
+}
+
+int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id)
+{
+ char buf[32];
+ int i, ret;
+
+ /* Sanity checks */
+ if (info == NULL || id >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ /* Create dir class device name */
+ sprintf(buf, "%.02d", id);
+
+ /* Setup the class struct */
+ memset(&info->class_dev, 0, sizeof(struct class_device));
+ info->class_dev.class = &pps_class;
+ strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN);
+ class_set_devdata(&info->class_dev, &pps_source[id]);
+
+ /* Register the new class */
+ ret = class_device_register(&info->class_dev);
+ if (unlikely(ret))
+ goto error_class_device_register;
+
+ /* Create info files */
+
+ /* Create file "assert" and "clear" according to source capability */
+ if (info->mode & PPS_CAPTUREASSERT) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+ i = 0;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+ if (info->mode & PPS_CAPTURECLEAR) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+ i = 1;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ return 0;
+
+error_class_device_create_file:
+ while (--i >= 0)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ class_device_unregister(&info->class_dev);
+ /* Here the release() method was already called */
+
+error_class_device_register:
+
+ return ret;
+}
+
+void pps_sysfs_unregister(void)
+{
+ class_unregister(&pps_class);
+}
+
+int pps_sysfs_register(void)
+{
+ return class_register(&pps_class);
+}
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c84dab0..0c9a307 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
up->ier |= UART_IER_MSI;
if (up->capabilities & UART_CAP_UUE)
up->ier |= UART_IER_UUE | UART_IER_RTOIE;
+ if (up->port.flags & UPF_HARDPPS_CD)
+ up->ier |= UART_IER_MSI; /* enable interrupts */
serial_out(up, UART_IER, up->ier);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 326020f..4a9906f 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -33,6 +33,7 @@
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
#include <linux/delay.h>
#include <linux/mutex.h>
+#include <linux/pps.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
@@ -633,6 +634,52 @@ static int uart_get_info(struct uart_state *state,
return 0;
}
+#ifdef CONFIG_PPS_CLIENT_UART
+
+static int
+uart_register_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ struct tty_driver *drv = port->info->tty->driver;
+ int ret;
+
+ snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d",
+ drv->driver_name, port->line);
+ snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d",
+ drv->name, port->line);
+
+ state->pps_info.mode = PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR,
+ -1 /* PPS ID is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register PPS source \"%s\"", state->pps_info.path);
+ return ret;
+ }
+ port->pps_source = ret;
+ pps_info("PPS source #%d \"%s\" added to the system ",
+ port->pps_source, state->pps_info.path);
+
+ return 0;
+}
+
+static void
+uart_unregister_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ pps_unregister_source(&state->pps_info);
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, state->pps_info.path);
+}
+
+#else
+
+#define uart_register_pps_port(state, port) do { } while (0)
+#define uart_unregister_pps_port(state, port) do { } while (0)
+
+#endif /* CONFIG_PPS_CLIENT_UART */
+
static int uart_set_info(struct uart_state *state,
struct serial_struct __user *newinfo)
{
@@ -807,11 +854,19 @@ static int uart_set_info(struct uart_state *state,
(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
check_and_exit:
+ /* PPS support enabled/disabled? */
+ if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) {
+ if (new_flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+ else
+ uart_unregister_pps_port(state, port);
+ }
+
retval = 0;
if (port->type == PORT_UNKNOWN)
goto exit;
if (state->info->flags & UIF_INITIALIZED) {
- if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
+ if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) ||
old_custom_divisor != port->custom_divisor) {
/*
* If they're setting up a custom divisor or speed,
@@ -2100,6 +2155,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
port->ops->config_port(port, flags);
}
+ /*
+ * Add the PPS support for the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+
if (port->type != PORT_UNKNOWN) {
unsigned long flags;
@@ -2349,6 +2410,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
mutex_unlock(&state->mutex);
/*
+ * Remove PPS support from the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_unregister_pps_port(state, port);
+
+ /*
* Remove the devices from the tty layer
*/
tty_unregister_device(drv->tty_driver, port->line);
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index e84ace1..36746dc 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -329,10 +329,15 @@
#define __NR_signalfd 321
#define __NR_timerfd 322
#define __NR_eventfd 323
+#define __NR_time_pps_cmd 324
+#define __NR_time_pps_getparams 325
+#define __NR_time_pps_setparams 326
+#define __NR_time_pps_getcap 327
+#define __NR_time_pps_fetch 328
#ifdef __KERNEL__
-#define NR_syscalls 324
+#define NR_syscalls 329
#define __ARCH_WANT_IPC_PARSE_VERSION
#define __ARCH_WANT_OLD_READDIR
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index f317c27..a10d20a 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -293,6 +293,7 @@ unifdef-y += pmu.h
unifdef-y += poll.h
unifdef-y += ppp_defs.h
unifdef-y += ppp-comp.h
+unifdef-y += pps.h
unifdef-y += ptrace.h
unifdef-y += qnx4_fs.h
unifdef-y += quota.h
diff --git a/include/linux/parport.h b/include/linux/parport.h
index 9cdd694..f53d9f4 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -100,6 +100,7 @@ typedef enum {
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
+#include <linux/pps.h>
#include <asm/system.h>
#include <asm/ptrace.h>
#include <asm/semaphore.h>
@@ -327,6 +328,11 @@ struct parport {
struct list_head full_list;
struct parport *slaves[3];
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ struct pps_source_info_s pps_info;
+ int pps_source; /* PPS source ID */
+#endif
};
#define DEFAULT_SPIN_TIME 500 /* us */
@@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode);
/* Lowlevel drivers _can_ call this support function to handle irqs. */
static __inline__ void parport_generic_irq(int irq, struct parport *port)
{
+#ifdef CONFIG_PPS_CLIENT_LP
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("parport_pc: PPS assert event at %lu on source #%d",
+ jiffies, port->pps_source);
+#endif
+
parport_ieee1284_interrupt (irq, port);
read_lock(&port->cad_lock);
if (port->cad && port->cad->irq_func)
diff --git a/include/linux/pps.h b/include/linux/pps.h
new file mode 100644
index 0000000..be32d16
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,207 @@
+/*
+ * pps.h -- PPS API kernel header.
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+
+#ifndef _PPS_H_
+#define _PPS_H_
+
+/* Implementation note: the logical states ``assert'' and ``clear''
+ * are implemented in terms of the chip register, i.e. ``assert''
+ * means the bit is set. */
+
+/*
+ * 3.2 New data structures
+ */
+
+#ifndef __KERNEL__
+#include <asm/types.h>
+#include <sys/time.h>
+#else
+#include <linux/time.h>
+#endif
+
+#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */
+#define PPS_API_VERS PPS_API_VERS_2
+#define LINUXPSS_API 1 /* mark LinuxPPS API */
+
+#define PPS_MAX_NAME_LEN 32
+
+struct pps_ktime {
+ __u64 sec;
+ __u32 nsec;
+};
+
+struct pps_kinfo {
+ __u32 assert_sequence; /* seq. num. of assert event */
+ __u32 clear_sequence; /* seq. num. of clear event */
+ struct pps_ktime assert_tu; /* time of assert event */
+ struct pps_ktime clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_kparams {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ struct pps_ktime assert_off_tu; /* offset compensation for assert */
+ struct pps_ktime clear_off_tu; /* offset compensation for clear */
+};
+
+/*
+ * 3.3 Mode bit definitions
+ */
+
+/* Device/implementation parameters */
+#define PPS_CAPTUREASSERT 0x01 /* capture assert events */
+#define PPS_CAPTURECLEAR 0x02 /* capture clear events */
+#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
+
+#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
+#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
+
+#define PPS_CANWAIT 0x100 /* can we wait for an event? */
+#define PPS_CANPOLL 0x200 /* bit reserved for future use */
+
+/* Kernel actions */
+#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
+#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
+
+/* Timestamp formats */
+#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
+#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
+
+/*
+ * 3.4.4 New functions: disciplining the kernel timebase
+ */
+
+/* Kernel consumers */
+#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */
+#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to
+ use a phase-locked loop */
+#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to
+ use a frequency-locked loop */
+/*
+ * Here begins the implementation-specific part!
+ */
+
+#include <linux/ioctl.h>
+
+struct pps_source_data_s {
+ int source;
+ char name[PPS_MAX_NAME_LEN];
+ char path[PPS_MAX_NAME_LEN];
+};
+
+#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *)
+#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *)
+
+#ifdef __KERNEL__
+
+#include <linux/device.h>
+
+/*
+ * Misc macros
+ */
+
+#define PPS_VERSION "4.0.0-rc4"
+
+#ifdef CONFIG_PPS_DEBUG
+#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#else
+#define pps_dbg(format, arg...) do {} while (0)
+#endif
+
+#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+
+/*
+ * Global defines
+ */
+
+#define PPS_MAX_SOURCES 16
+
+/* The specific PPS source info */
+struct pps_source_info_s {
+ char name[PPS_MAX_NAME_LEN]; /* simbolic name */
+ char path[PPS_MAX_NAME_LEN]; /* path of connected device */
+ int mode; /* PPS's allowed mode */
+
+ void (*echo)(int source, int event, void *data);/* the PPS echo function */
+
+ /* sysfs section */
+ struct class_device class_dev;
+};
+
+/* The main struct */
+struct pps_s {
+ struct pps_source_info_s *info; /* PSS source info */
+
+ struct pps_kparams params; /* PPS's current params */
+
+ volatile __u32 assert_sequence; /* PPS' assert event seq # */
+ volatile __u32 clear_sequence; /* PPS' clear event seq # */
+ volatile struct pps_ktime assert_tu;
+ volatile struct pps_ktime clear_tu;
+ int current_mode; /* PPS mode at event time */
+
+ int go; /* PPS event is arrived? */
+ wait_queue_head_t queue; /* PPS event queue */
+};
+
+/*
+ * Global variables
+ */
+
+extern struct pps_s pps_source[PPS_MAX_SOURCES];
+extern struct mutex pps_mutex;
+extern struct pps_source_info_s dummy_info;
+
+/*
+ * Global functions
+ */
+
+static inline int pps_is_allocated(int source)
+{
+ return pps_source[source].info != &dummy_info;
+}
+
+#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev)
+
+/*
+ * Exported functions
+ */
+
+extern int pps_register_source(struct pps_source_info_s *info,
+ int default_params, int try_id);
+extern void pps_unregister_source(struct pps_source_info_s *info);
+extern void pps_event(int source, int event, void *data);
+
+extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info,
+ int id);
+extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info);
+extern int pps_sysfs_register(void);
+extern void pps_sysfs_unregister(void);
+
+#endif /* __KERNEL__ */
+
+#endif /* _PPS_H_ */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 7f2c99d..ba4503e 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -153,6 +153,7 @@
#include <linux/tty.h>
#include <linux/mutex.h>
#include <linux/sysrq.h>
+#include <linux/pps.h>
struct uart_port;
struct uart_info;
@@ -232,6 +233,9 @@ struct uart_port {
unsigned char regshift; /* reg offset shift */
unsigned char iotype; /* io access style */
unsigned char unused1;
+#ifdef CONFIG_PPS_CLIENT_UART
+ int pps_source; /* PPS source ID */
+#endif
#define UPIO_PORT (0)
#define UPIO_HUB6 (1)
@@ -276,7 +280,8 @@ struct uart_port {
#define UPF_IOREMAP ((__force upf_t) (1 << 31))
#define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))
-#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
+#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\
+ |UPF_HARDPPS_CD))
unsigned int mctrl; /* current modem ctrl settings */
unsigned int timeout; /* character-based timeout */
@@ -308,6 +313,10 @@ struct uart_state {
struct uart_info *info;
struct uart_port *port;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct pps_source_info_s pps_info;
+#endif
+
struct mutex mutex;
};
@@ -472,13 +481,27 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
- port->icount.dcd++;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct tty_driver *drv = port->info->tty->driver;
-#ifdef CONFIG_HARD_PPS
- if ((port->flags & UPF_HARDPPS_CD) && status)
- hardpps();
+ if (port->flags & UPF_HARDPPS_CD) {
+ if (status) {
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("%s%d: PPS assert event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ }
+ else {
+ pps_event(port->pps_source, PPS_CAPTURECLEAR, port);
+ pps_dbg("%s%d: PPS clear event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ }
+ }
#endif
+ port->icount.dcd++;
+
if (info->flags & UIF_CHECK_CD) {
if (status)
wake_up_interruptible(&info->open_wait);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 83d0ec1..bfc8899 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -65,6 +65,7 @@ struct getcpu_cache;
#include <asm/signal.h>
#include <linux/quota.h>
#include <linux/key.h>
+#include <linux/pps.h>
asmlinkage long sys_time(time_t __user *tloc);
asmlinkage long sys_stime(time_t __user *tptr);
@@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags,
const struct itimerspec __user *utmr);
asmlinkage long sys_eventfd(unsigned int count);
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg);
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode);
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout);
+
int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 7e11e2c..e0fccc2 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -148,3 +148,10 @@ cond_syscall(sys_timerfd);
cond_syscall(compat_sys_signalfd);
cond_syscall(compat_sys_timerfd);
cond_syscall(sys_eventfd);
+
+/* PPS dependent */
+cond_syscall(sys_time_pps_find);
+cond_syscall(sys_time_pps_getparams);
+cond_syscall(sys_time_pps_setparams);
+cond_syscall(sys_time_pps_getcap);
+cond_syscall(sys_time_pps_fetch);
^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-17 18:05 [PATCH] LinuxPPS - definitive version Rodolfo Giometti
@ 2007-07-23 13:35 ` David Woodhouse
2007-07-23 16:04 ` Rodolfo Giometti
` (2 more replies)
0 siblings, 3 replies; 43+ messages in thread
From: David Woodhouse @ 2007-07-23 13:35 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton
On Tue, 2007-07-17 at 20:05 +0200, Rodolfo Giometti wrote:
> Hello,
>
> here my last patch for PPS support.
>
> In my opinion it should be ok for inclusion... please, let me know if
> something should be still changed.
s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt
Please feed it to scripts/checkpatch.pl -- you can ignore all the
warnings about lines greater than 80 characters, and the complete crap
about "declaring multiple variables together should be avoided", but
some of what it points out is valid. Including the one about 'volatile'
-- your explanation lacked credibility. If you really need 'volatile'
then put it at the places you actually need it; not the declaration of
the structure.
You've also reverted to structures which vary between 32-bit and 64-bit
userspace, because they use 'long' and 'struct timespec', but you
haven't provided the compat_* routines which are then necessary.
+typedef int pps_handle_t; /* represents a PPS source */
+typedef unsigned long pps_seq_t; /* sequence number */
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
+typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s
tamps */
+typedef struct pps_info pps_info_t;
+typedef struct pps_params pps_params_t;
Don't do this for the structures. It's dubious enough for the integer
types.
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-23 13:35 ` David Woodhouse
@ 2007-07-23 16:04 ` Rodolfo Giometti
2007-07-23 19:28 ` Andrew Morton
2007-07-24 8:00 ` Rodolfo Giometti
2 siblings, 0 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-23 16:04 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote:
>
> s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt
Fixed.
> Please feed it to scripts/checkpatch.pl -- you can ignore all the
> warnings about lines greater than 80 characters, and the complete crap
> about "declaring multiple variables together should be avoided", but
> some of what it points out is valid. Including the one about 'volatile'
Ok, I'll do it.
> -- your explanation lacked credibility. If you really need 'volatile'
> then put it at the places you actually need it; not the declaration of
> the structure.
About this debate, please, take a look at the pps_event() function:
void pps_event(int source, int event, void *data)
{
struct timespec __ts;
struct pps_ktime ts;
/* First of all we get the time stamp... */
getnstimeofday(&__ts);
/* ... and translate it to PPS time data struct */
ts.sec = __ts.tv_sec;
ts.nsec = __ts.tv_nsec;
if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
pps_err("unknow event (%x) for source %d", event, source);
return;
}
/* We wish not using locks at all into this function... a possible
* solution is to check the "info" field against the pointer to
* "dummy_info".
* If "info" points to "dummy_info" we can return doing nothing since,
* even if a new PPS source is registered by another CPU we can
* safely not register current event.
* If "info" points to a valid PPS source's info data we can continue
* without problem since, even if current PPS source is deregistered
* by another CPU, we still continue writing data into a valid area
* (dummy_info).
*/
if (pps_source[source].info == &dummy_info)
return;
/* Must call the echo function? */
if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
pps_source[source].info->echo(source, event, data);
/* Check the event */
pps_source[source].current_mode = pps_source[source].params.mode;
if (event & PPS_CAPTUREASSERT) {
/* We have to add an offset? */
if (pps_source[source].params.mode & PPS_OFFSETASSERT)
pps_add_offset(&ts,
&pps_source[source].params.assert_off_tu);
/* Save the time stamp */
pps_source[source].assert_tu = ts;
pps_source[source].assert_sequence++;
pps_dbg("capture assert seq #%u for source %d",
pps_source[source].assert_sequence, source);
}
if (event & PPS_CAPTURECLEAR) {
/* We have to add an offset? */
if (pps_source[source].params.mode & PPS_OFFSETCLEAR)
pps_add_offset(&ts,
&pps_source[source].params.clear_off_tu);
/* Save the time stamp */
pps_source[source].clear_tu = ts;
pps_source[source].clear_sequence++;
pps_dbg("capture clear seq #%u for source %d",
pps_source[source].clear_sequence, source);
}
pps_source[source].go = ~0;
wake_up_interruptible(&pps_source[source].queue);
}
The problems should arise at:
if (pps_source[source].info == &dummy_info)
return;
but as explained into the comment there should be no problems at
all...
About "where" to put the "volatile" attribute I don't understand what
you mean... such attribute is needed (IMHO) for "assert_sequence"&C,
where should I put it? :-o
> You've also reverted to structures which vary between 32-bit and 64-bit
> userspace, because they use 'long' and 'struct timespec', but you
> haven't provided the compat_* routines which are then necessary.
As already suggested I used fixed size variables. See the new struct
"struct pps_ktime".
> +typedef int pps_handle_t; /* represents a PPS source */
> +typedef unsigned long pps_seq_t; /* sequence number */
> +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
> +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s
> tamps */
> +typedef struct pps_info pps_info_t;
> +typedef struct pps_params pps_params_t;
>
> Don't do this for the structures. It's dubious enough for the integer
> types.
Such code is for userland since RFC2783 requires such types... I moved
all userland code into Documentation/pps/timepps.h which can be used
by userland programs whose require RFC compatibility.
I'll post a new patch ASAP.
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-23 13:35 ` David Woodhouse
2007-07-23 16:04 ` Rodolfo Giometti
@ 2007-07-23 19:28 ` Andrew Morton
2007-07-23 19:48 ` David Woodhouse
2007-07-24 8:00 ` Rodolfo Giometti
2 siblings, 1 reply; 43+ messages in thread
From: Andrew Morton @ 2007-07-23 19:28 UTC (permalink / raw)
To: David Woodhouse; +Cc: Rodolfo Giometti, linux-kernel
On Mon, 23 Jul 2007 14:35:16 +0100
David Woodhouse <dwmw2@infradead.org> wrote:
> Please feed it to scripts/checkpatch.pl -- you can ignore all the
> warnings about lines greater than 80 characters, and the complete crap
> about "declaring multiple variables together should be avoided", but
> some of what it points out is valid.
The above are David's opinions. Many, probably most kernel developers do not
agree with them.
And there are good reasons for ignoring David's opinions here. To
understand those reasons, try looking at some MTD code.
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-23 19:28 ` Andrew Morton
@ 2007-07-23 19:48 ` David Woodhouse
0 siblings, 0 replies; 43+ messages in thread
From: David Woodhouse @ 2007-07-23 19:48 UTC (permalink / raw)
To: Andrew Morton; +Cc: Rodolfo Giometti, linux-kernel
On Mon, 2007-07-23 at 12:28 -0700, Andrew Morton wrote:
> On Mon, 23 Jul 2007 14:35:16 +0100
> David Woodhouse <dwmw2@infradead.org> wrote:
>
> > Please feed it to scripts/checkpatch.pl -- you can ignore all the
> > warnings about lines greater than 80 characters, and the complete crap
> > about "declaring multiple variables together should be avoided", but
> > some of what it points out is valid.
>
> The above are David's opinions. Many, probably most kernel developers do not
> agree with them.
Linus called the 80-column thing a 'Nazi dream' and I'm inclined to
agree with him. It's something to bear in mind, of course, but sometimes
it's best ignored.
And the 'declaring multiple variables together' is something I've
_never_ heard of. Might be applicable if you're actually giving them
initial values, but just declaring them together is fine, surely?
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-23 13:35 ` David Woodhouse
2007-07-23 16:04 ` Rodolfo Giometti
2007-07-23 19:28 ` Andrew Morton
@ 2007-07-24 8:00 ` Rodolfo Giometti
2007-07-24 13:49 ` David Woodhouse
2 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-24 8:00 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
[-- Attachment #1: Type: text/plain, Size: 1902 bytes --]
On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote:
>
> s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt
Fixed.
> Please feed it to scripts/checkpatch.pl -- you can ignore all the
> warnings about lines greater than 80 characters, and the complete crap
> about "declaring multiple variables together should be avoided", but
Done. Most fixed.
> some of what it points out is valid. Including the one about 'volatile'
> -- your explanation lacked credibility. If you really need 'volatile'
> then put it at the places you actually need it; not the declaration of
> the structure.
Can you please explain better where should I put the 'volatile'
attribute? :-o
> You've also reverted to structures which vary between 32-bit and 64-bit
> userspace, because they use 'long' and 'struct timespec', but you
> haven't provided the compat_* routines which are then necessary.
This should be not needed due new 'struct pps_ktime'.
> +typedef int pps_handle_t; /* represents a PPS source */
> +typedef unsigned long pps_seq_t; /* sequence number */
> +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
> +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s
> tamps */
> +typedef struct pps_info pps_info_t;
> +typedef struct pps_params pps_params_t;
>
> Don't do this for the structures. It's dubious enough for the integer
> types.
These typedefs are into timepps.h which is an userland file (located
into Documentation/pps/) and are requested by the RFC.
Attached you can find my last patch.
Thanks again,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
[-- Attachment #2: ntp-pps-2.6.22-bis.diff --]
[-- Type: text/plain, Size: 68285 bytes --]
diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
new file mode 100644
index 0000000..a2660a2
--- /dev/null
+++ b/Documentation/pps/Makefile
@@ -0,0 +1,27 @@
+TARGETS = ppstest ppsctl
+
+CFLAGS += -Wall -O2 -D_GNU_SOURCE
+CFLAGS += -I .
+CFLAGS += -ggdb
+
+# -- Actions section ----------------------------------------------------------
+
+.PHONY : all depend dep
+
+all : .depend $(TARGETS)
+
+.depend depend dep :
+ $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
+
+
+# -- Clean section ------------------------------------------------------------
+
+.PHONY : clean
+
+clean :
+ rm -f *.o *~ core .depend
+ rm -f ${TARGETS}
diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
new file mode 100644
index 0000000..511fa36
--- /dev/null
+++ b/Documentation/pps/pps.txt
@@ -0,0 +1,211 @@
+
+ PPS - Pulse Per Second
+ ----------------------
+
+(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com>
+
+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.
+
+
+
+Overview
+--------
+
+LinuxPPS provides a programming interface (API) to define into the
+system several PPS sources.
+
+PPS means "pulse per second" and a PPS source is just a device which
+provides a high precision signal each second so that an application
+can use it to adjust system clock time.
+
+A PPS source can be connected to a serial port (usually to the Data
+Carrier Detect pin) or to a parallel port (ACK-pin) or to a special
+CPU's GPIOs (this is the common case in embedded systems) but in each
+case when a new pulse comes the system must apply to it a timestamp
+and record it for the userland.
+
+Common use is the combination of the NTPD as userland program with a
+GPS receiver as PPS source to obtain a wallclock-time with
+sub-millisecond synchronisation to UTC.
+
+
+RFC considerations
+------------------
+
+While implementing a PPS API as RFC 2783 defines and using an embedded
+CPU GPIO-Pin as physical link to the signal, I encountered a deeper
+problem:
+
+ At startup it needs a file descriptor as argument for the function
+ time_pps_create().
+
+This implies that the source has a /dev/... entry. This assumption is
+ok for the serial and parallel port, where you can do something
+useful besides(!) the gathering of timestamps as it is the central
+task for a PPS-API. But this assumption does not work for a single
+purpose GPIO line. In this case even basic file-related functionality
+(like read() and write()) makes no sense at all and should not be a
+precondition for the use of a PPS-API.
+
+The problem can be simply solved if you change the original RFC 2783:
+
+ pps_handle_t type is an opaque __scalar type__ used to represent a
+ PPS source within the API
+
+into a modified:
+
+ pps_handle_t type is an opaque __variable__ used to represent a PPS
+ source within the API and programs should not access it directly to
+ it due to its opacity.
+
+This change seems to be neglibile because even the original RFC 2783
+does not encourage programs to check (read: use) the pps_handle_t
+variable before calling the time_pps_*() functions, since each
+function should do this job internally.
+
+If I intentionally separate the concept of "file descriptor" from the
+concept of the "PPS source" I'm obliged to provide a solution to find
+and register a PPS-source without using a file descriptor: it's done
+by the functions time_pps_findsource() and time_pps_findpath() now.
+
+According to this current NTPD drivers' code should be modified as
+follows:
+
++#ifdef PPS_HAVE_FINDPATH
++ /* Get the PPS source's real name */
++ fd = readlink(link, path, STRING_LEN-1);
++ if (fd <= 0)
++ strncpy(path, link, STRING_LEN);
++ else
++ path[fd] = '\0';
++
++ /* Try to find the source */
++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
++ if (fd < 0) {
++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" "
++ "in the system", path);
++ return 1;
++ }
++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"",
++ fd, path, id);
++#endif /* PPS_HAVE_FINDPATH */
++
++
+ if (time_pps_create(fd, &pps_handle) < 0) {
+- pps_handle = 0;
+ msyslog(LOG_ERR, "refclock: time_pps_create failed: %m");
+ }
+
+
+Coding example
+--------------
+
+To register a PPS source into the kernel you should define a struct
+pps_source_info_s as follow:
+
+ static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+ };
+
+and then calling the function pps_register_source() in your
+intialization routine as follow:
+
+ source = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+
+The pps_register_source() prototype is:
+
+ int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+
+where "info" is a pointer to a structure that describes a particular
+PPS source, "default_params" tells the system what the initial default
+parameters for the device should be (is obvious that these parameters
+must be a subset of ones defined into the struct
+pps_source_info_s which describe the capabilities of the driver)
+and "try_id" can be used to force a particular ID for your device into
+the system (just use -1 if you wish the system chooses one for you).
+
+Once you have registered a new PPS source into the system you can
+signal an assert event (for example in the interrupt handler routine)
+just using:
+
+ pps_event(source, PPS_CAPTUREASSERT, ptr);
+
+The same function may also run the defined echo function
+(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user
+asked for that... etc..
+
+Please see the file drivers/pps/clients/ktimer.c for an example code.
+
+
+SYSFS support
+-------------
+
+The SYSFS support is enabled by default if the SYSFS filesystem is
+enabled in the kernel and it provides a new class:
+
+ $ ls /sys/class/pps/
+ 00/ 01/ 02/
+
+Every directory is the ID of a PPS sources defined into the system and
+inside you find several files:
+
+ $ ls /sys/class/pps/00/
+ assert clear echo mode name path subsystem@ uevent
+
+Inside each "assert" and "clear" file you can find the timestamp and a
+sequence number:
+
+ $ cat /sys/class/pps/00/assert
+ 1170026870.983207967#8
+
+Where before the "#" is the timestamp in seconds and after it is the
+sequence number. Other files are:
+
+* echo: reports if the PPS source has an echo function or not;
+
+* mode: reports available PPS functioning modes;
+
+* name: reports the PPS source's name;
+
+* path: reports the PPS source's device path, that is the device the
+ PPS source is connected to (if it exists).
+
+
+Testing the PPS support
+-----------------------
+
+In order to test the PPS support even without specific hardware you can use
+the ktimer driver (see the client subsection in the PPS configuration menu)
+and the userland tools provided into Documentaion/pps/ directory.
+
+Once you have enabled the compilation of ktimer just modprobe it (if
+not statically compiled):
+
+ # modprobe ktimer
+
+and the run ppstest as follow:
+
+ $ ./ppstest
+ found PPS source #0 "ktimer" on ""
+ ok, found 1 source(s), now start fetching data...
+ source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0
+ source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0
+
+Please, note that to compile userland programs you need the file timepps.h
+(see Documentation/pps/).
diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c
new file mode 100644
index 0000000..17afcbd
--- /dev/null
+++ b/Documentation/pps/ppsctl.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/serial.h>
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);
+
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd, ret;
+ struct serial_struct ss;
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0) {
+ perror("open");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCGSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCGSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ if (argc < 3) { /* just read PPS status */
+ printf("PPS is %sabled\n",
+ ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");
+ exit(EXIT_SUCCESS);
+ }
+
+ if (argv[2][0] == 'e' || argv[2][0] == '1')
+ ss.flags |= ASYNC_HARDPPS_CD;
+ else if (argv[2][0] == 'd' || argv[2][0] == '0')
+ ss.flags &= ~ASYNC_HARDPPS_CD;
+ else {
+ fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCSSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCSSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
new file mode 100644
index 0000000..bfd1064
--- /dev/null
+++ b/Documentation/pps/ppstest.c
@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <timepps.h>
+
+#define STRING_LEN PPS_MAX_NAME_LEN
+
+int find_source(int try_link, char *link, pps_handle_t *handle,
+ int *avail_mode)
+{
+ int num = -1;
+ char id[STRING_LEN] = "", /* no ID string by default */
+ path[STRING_LEN];
+ pps_params_t params;
+ int ret;
+
+ if (try_link) {
+ printf("trying PPS source \"%s\"\n", link);
+#ifdef PPS_HAVE_FINDPATH
+ /* Get the PPS source's real name */
+ time_pps_readlink(link, STRING_LEN, path, STRING_LEN);
+
+ /* Try to find the source by using the supplied "path" name */
+ ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
+ if (ret < 0)
+ goto exit;
+ num = ret;
+#else
+#warning "cannot use time_pps_findpath()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDPATH */
+ }
+#ifdef PPS_HAVE_FINDSOURCE
+ /* Try to find the source (by using "index = -1" we ask just
+ * for a generic source) */
+ ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN);
+#else
+#warning "cannot use time_pps_findsource()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDSOURCE */
+ if (ret < 0) {
+exit:
+ fprintf(stderr, "no available PPS source in the system\n");
+ return -1;
+ }
+ num = ret;
+ printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path);
+
+ /* If "path" is not NULL we should *at least* open the pointed
+ * device in order to enable the interrupts generation.
+ * Note that this can be NOT enough anyway, infact you may need sending
+ * additional commands to your GPS antenna before it starts sending
+ * the PPS signal. */
+ if (strlen(path)) {
+ ret = open(path, O_RDWR);
+ if (ret < 0) {
+ fprintf(stderr, "cannot open \"%s\" (%m)\n", path);
+ return -1;
+ }
+ }
+
+ /* Open the PPS source */
+ ret = time_pps_create(num, handle);
+ if (ret < 0) {
+ fprintf(stderr, "cannot create a PPS source (%m)\n");
+ return -1;
+ }
+
+ /* Find out what features are supported */
+ ret = time_pps_getcap(*handle, avail_mode);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get capabilities (%m)\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
+ fprintf(stderr, "cannot CAPTUREASSERT\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_OFFSETASSERT) == 0) {
+ fprintf(stderr, "cannot OFFSETASSERT\n");
+ return -1;
+ }
+
+ /* Capture assert timestamps, and compensate for a 675 nsec
+ * propagation delay */
+ ret = time_pps_getparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get parameters (%m)\n");
+ return -1;
+ }
+ params.assert_offset.tv_sec = 0;
+ params.assert_offset.tv_nsec = 675;
+ params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT;
+ ret = time_pps_setparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot set parameters (%m)\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fetch_source(int i, pps_handle_t *handle, int *avail_mode)
+{
+ struct timespec timeout;
+ pps_info_t infobuf;
+ int ret;
+
+ /* create a zero-valued timeout */
+ timeout.tv_sec = 3;
+ timeout.tv_nsec = 0;
+
+retry:
+ if (*avail_mode & PPS_CANWAIT) {
+ /* waits for the next event */
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ } else {
+ sleep(1);
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ }
+ if (ret < 0) {
+ if (ret == -EINTR) {
+ fprintf(stderr, "time_pps_fetch() got a signal!\n");
+ goto retry;
+ }
+
+ fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);
+ return -1;
+ }
+
+ printf("source %d - "
+ "assert %ld.%09ld, sequence: %ld - "
+ "clear %ld.%09ld, sequence: %ld\n",
+ i,
+ infobuf.assert_timestamp.tv_sec,
+ infobuf.assert_timestamp.tv_nsec,
+ infobuf.assert_sequence,
+ infobuf.clear_timestamp.tv_sec,
+ infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ int num, try_link = 0; /* by default use findsource */
+ char link[STRING_LEN] = "/dev/gps0"; /* just a default device */
+ pps_handle_t handle[4];
+ int avail_mode[4];
+ int i = 0, ret;
+
+ if (argc == 1) {
+ ret = find_source(try_link, link, &handle[0], &avail_mode[0]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+
+ num = 1;
+ } else {
+ for (i = 1; i < argc && i <= 4; i++) {
+ ret = sscanf(argv[i], "%d", &num);
+ if (ret < 1) {
+ try_link = ~0;
+ strncpy(link, argv[i], STRING_LEN);
+ }
+
+ ret =
+ find_source(try_link, link, &handle[i - 1],
+ &avail_mode[i - 1]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+ }
+
+ num = i - 1;
+ }
+
+ printf("ok, found %d source(s), now start fetching data...\n", num);
+
+ /* loop, printing the most recent timestamp every second or so */
+ while (1) {
+ for (i = 0; i < num; i++) {
+ ret = fetch_source(i, &handle[i], &avail_mode[i]);
+ if (ret < 0 && errno != ETIMEDOUT)
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ for (; i >= 0; i--)
+ time_pps_destroy(handle[i]);
+
+ return 0;
+}
diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
new file mode 100644
index 0000000..dee1782
--- /dev/null
+++ b/Documentation/pps/timepps.h
@@ -0,0 +1,234 @@
+/*
+ * timepps.h -- PPS API main header
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+#ifndef _SYS_TIMEPPS_H_
+#define _SYS_TIMEPPS_H_
+
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <errno.h>
+#include <linux/pps.h>
+
+/*
+ * New data structures
+ */
+
+struct ntp_fp {
+ unsigned int integral;
+ unsigned int fractional;
+};
+
+union pps_timeu {
+ struct timespec tspec;
+ struct ntp_fp ntpfp;
+ unsigned long longpad[3];
+};
+
+struct pps_info {
+ unsigned long assert_sequence; /* seq. num. of assert event */
+ unsigned long clear_sequence; /* seq. num. of clear event */
+ union pps_timeu assert_tu; /* time of assert event */
+ union pps_timeu clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_params {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ union pps_timeu assert_off_tu; /* offset compensation for assert */
+ union pps_timeu clear_off_tu; /* offset compensation for clear */
+};
+
+typedef int pps_handle_t; /* represents a PPS source */
+typedef unsigned long pps_seq_t; /* sequence number */
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
+typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */
+typedef struct pps_info pps_info_t;
+typedef struct pps_params pps_params_t;
+
+#define assert_timestamp assert_tu.tspec
+#define clear_timestamp clear_tu.tspec
+
+#define assert_timestamp_ntpfp assert_tu.ntpfp
+#define clear_timestamp_ntpfp clear_tu.ntpfp
+
+#define assert_offset assert_off_tu.tspec
+#define clear_offset clear_off_tu.tspec
+
+#define assert_offset_ntpfp assert_off_tu.ntpfp
+#define clear_offset_ntpfp clear_off_tu.ntpfp
+
+/*
+ * The PPS API
+ */
+
+#define PPS_HAVE_FINDSOURCE 1
+#define pps_min(a, b) (a) < (b) ? a : b
+int time_pps_findsource(int index, char *path, int pathlen, char *idstring,
+ int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ data.source = index;
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+ strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+/* Defined iff PPS_HAVE_FINDPATH is defined */
+void time_pps_readlink(char *link, int linklen, char *path, int pathlen)
+{
+ int i;
+
+ i = readlink(link, path, pathlen - 1);
+ if (i <= 0) {
+ /* "link" is not a valid symbolic so we directly use it */
+ strncpy(path, link, linklen <= pathlen ? linklen : pathlen);
+ return;
+ }
+
+ /* Return the file name where "link" points to */
+ path[i] = '\0';
+}
+
+#define PPS_HAVE_FINDPATH 1
+int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+int time_pps_create(int source, pps_handle_t *handle)
+{
+ if (!handle) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* In LinuxPPS there are no differences between a PPS source and
+ * a PPS handle so we return the same value.
+ */
+ *handle = source;
+
+ return 0;
+}
+
+int time_pps_destroy(pps_handle_t handle)
+{
+ /* Nothing to destroy here */
+
+ return 0;
+}
+
+int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
+{
+ int ret;
+ struct pps_kparams __ppsparams;
+
+ ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+
+ ppsparams->api_version = __ppsparams.api_version;
+ ppsparams->mode = __ppsparams.mode;
+ ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;
+ ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;
+ ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;
+ ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;
+
+ return ret;
+}
+
+int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
+{
+ struct pps_kparams __ppsparams;
+
+ __ppsparams.api_version = ppsparams->api_version;
+ __ppsparams.mode = ppsparams->mode;
+ __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;
+ __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;
+ __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;
+ __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;
+
+ return syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+}
+
+/* Get capabilities for handle */
+int time_pps_getcap(pps_handle_t handle, int *mode)
+{
+ return syscall(__NR_time_pps_getcap, handle, mode);
+}
+
+int time_pps_fetch(pps_handle_t handle, const int tsformat,
+ pps_info_t *ppsinfobuf, const struct timespec *timeout)
+{
+ struct pps_kinfo __ppsinfobuf;
+ struct pps_ktime __timeout;
+ int ret;
+
+ /* Sanity checks */
+ if (tsformat != PPS_TSFMT_TSPEC) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (timeout) {
+ __timeout.sec = timeout->tv_sec;
+ __timeout.nsec = timeout->tv_nsec;
+ }
+
+ ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf,
+ timeout ? &__timeout : NULL);
+
+ ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence;
+ ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence;
+ ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec;
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec;
+ ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec;
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec;
+ ppsinfobuf->current_mode = __ppsinfobuf.current_mode;
+
+ return ret;
+}
+
+int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
+ const int edge, const int tsformat)
+{
+ /* LinuxPPS doesn't implement kernel consumer feature */
+ errno = EOPNOTSUPP;
+ return -1;
+}
+
+#endif /* _SYS_TIMEPPS_H_ */
diff --git a/MAINTAINERS b/MAINTAINERS
index df40a4e..17e9a02 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2903,6 +2903,13 @@ P: Michal Ostrowski
M: mostrows@speakeasy.net
S: Maintained
+PPS SUPPORT
+P: Rodolfo Giometti
+M: giometti@enneenne.com
+W: http://wiki.enneenne.com/index.php/LinuxPPS_support
+L: linuxpps@ml.enneenne.com
+S: Maintained
+
PREEMPTIBLE KERNEL
P: Robert Love
M: rml@tech9.net
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index bf6adce..f1bf4ff 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -323,3 +323,8 @@ ENTRY(sys_call_table)
.long sys_signalfd
.long sys_timerfd
.long sys_eventfd
+ .long sys_time_pps_cmd
+ .long sys_time_pps_getparams /* 325 */
+ .long sys_time_pps_setparams
+ .long sys_time_pps_getcap
+ .long sys_time_pps_fetch
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 050323f..bb54cab 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
source "drivers/spi/Kconfig"
+source "drivers/pps/Kconfig"
+
source "drivers/w1/Kconfig"
source "drivers/hwmon/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index adad2f3..985d495 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/
obj-$(CONFIG_I2O) += message/
obj-$(CONFIG_RTC_LIB) += rtc/
obj-y += i2c/
+obj-$(CONFIG_PPS) += pps/
obj-$(CONFIG_W1) += w1/
obj-$(CONFIG_HWMON) += hwmon/
obj-$(CONFIG_PHONE) += telephony/
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 62051f8..403753f 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -746,6 +746,27 @@ static struct console lpcons = {
#endif /* console on line printer */
+/* Support for PPS signal on the line printer */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+
+static void lp_pps_echo(int source, int event, void *data)
+{
+ struct parport *port = data;
+ unsigned char status = parport_read_status(port);
+
+ /* echo event via SEL bit */
+ parport_write_control(port,
+ parport_read_control(port) | PARPORT_CONTROL_SELECT);
+
+ /* signal no event */
+ if ((status & PARPORT_STATUS_ACK) != 0)
+ parport_write_control(port,
+ parport_read_control(port) & ~PARPORT_CONTROL_SELECT);
+}
+
+#endif
+
/* --- initialisation code ------------------------------------- */
static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
@@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port)
}
#endif
+#ifdef CONFIG_PPS_CLIENT_LP
+ snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr);
+
+ /* No PPS support if lp port has no IRQ line */
+ if (port->irq != PARPORT_IRQ_NONE) {
+ strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN);
+
+ port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ port->pps_info.echo = lp_pps_echo;
+
+ port->pps_source = pps_register_source(&(port->pps_info),
+ PPS_CAPTUREASSERT | PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (port->pps_source < 0)
+ pps_err("cannot register PPS source \"%s\"",
+ port->pps_info.path);
+ else
+ pps_info("PPS source #%d \"%s\" added to the system",
+ port->pps_source, port->pps_info.path);
+ } else {
+ port->pps_source = -1;
+ pps_err("PPS support disabled due port \"%s\" is in polling mode",
+ port->pps_info.path);
+ }
+#endif
+
return 0;
}
@@ -860,6 +910,14 @@ static void lp_detach (struct parport *port)
console_registered = NULL;
}
#endif /* CONFIG_LP_CONSOLE */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ if (port->pps_source >= 0) {
+ pps_unregister_source(&(port->pps_info));
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, port->pps_info.path);
+ }
+#endif
}
static struct parport_driver lp_driver = {
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 0000000..a00b59a
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,31 @@
+#
+# PPS support configuration
+#
+
+menu "PPS support"
+
+config PPS
+ bool "PPS support"
+ depends on EXPERIMENTAL
+ ---help---
+ PPS (Pulse Per Second) is a special pulse provided by some GPS
+ antennae. Userland can use it to get an high time reference.
+
+ Some antennae's PPS signals are connected with the CD (Carrier
+ Detect) pin of the serial line they use to communicate with the
+ host. In this case use the SERIAL_LINE client support.
+
+ Some antennae's PPS signals are connected with some special host
+ inputs so you have to enable the corresponding client support.
+
+config PPS_DEBUG
+ bool "PPS debugging messages"
+ depends on PPS
+ help
+ Say Y here if you want the PPS support to produce a bunch of debug
+ messages to the system log. Select this if you are having a
+ problem with PPS support and want to see more of what is going on.
+
+source drivers/pps/clients/Kconfig
+
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 0000000..76101cd
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the PPS core.
+#
+
+pps_core-objs += pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS) += pps_core.o
+obj-y += clients/
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 0000000..58a1e55
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,30 @@
+#
+# PPS clients configuration
+#
+
+if PPS
+
+comment "PPS clients support"
+
+config PPS_CLIENT_KTIMER
+ tristate "Kernel timer client (Testing client, use for debug)"
+ help
+ If you say yes here you get support for a PPS debugging client
+ which uses a kernel timer to generate the PPS signal.
+
+ This driver can also be built as a module. If so, the module
+ will be called ktimer.ko.
+
+config PPS_CLIENT_UART
+ bool "UART serial support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the CD (Carrier Detect) pin of your serial port.
+
+config PPS_CLIENT_LP
+ bool "Parallel printer support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the interrupt pin of your parallel port.
+
+endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
new file mode 100644
index 0000000..10d1dfa
--- /dev/null
+++ b/drivers/pps/clients/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for PPS clients.
+#
+
+obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
+
diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c
new file mode 100644
index 0000000..efd6eba
--- /dev/null
+++ b/drivers/pps/clients/ktimer.c
@@ -0,0 +1,114 @@
+/*
+ * ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+
+#include <linux/pps.h>
+
+/*
+ * Global variables
+ */
+
+static int source;
+static struct timer_list ktimer;
+
+/*
+ * The kernel timer
+ */
+
+static void pps_ktimer_event(unsigned long ptr)
+{
+ pps_info("PPS event at %lu", jiffies);
+
+ pps_event(source, PPS_CAPTUREASSERT, NULL);
+
+ mod_timer(&ktimer, jiffies + HZ);
+}
+
+/*
+ * The echo function
+ */
+
+static void pps_ktimer_echo(int source, int event, void *data)
+{
+ pps_info("echo %s %s for source %d",
+ event & PPS_CAPTUREASSERT ? "assert" : "",
+ event & PPS_CAPTURECLEAR ? "clear" : "",
+ source);
+}
+
+/*
+ * The PPS info struct
+ */
+
+static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+ del_timer_sync(&ktimer);
+ pps_unregister_source(&pps_ktimer_info);
+
+ pps_info("ktimer PPS source unregistered");
+}
+
+static int __init pps_ktimer_init(void)
+{
+ int ret;
+
+ ret = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register ktimer source");
+ return ret;
+ }
+ source = ret;
+
+ setup_timer(&ktimer, pps_ktimer_event, 0);
+ mod_timer(&ktimer, jiffies + HZ);
+
+ pps_info("ktimer PPS source registered at %d", source);
+
+ return 0;
+}
+
+module_init(pps_ktimer_init);
+module_exit(pps_ktimer_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 0000000..19c21e5
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,215 @@
+/*
+ * kapi.c -- kernel API
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/pps.h>
+
+/*
+ * Local functions
+ */
+
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+ ts->nsec += offset->nsec;
+ if (ts->nsec >= NSEC_PER_SEC) {
+ ts->nsec -= NSEC_PER_SEC;
+ ts->sec++;
+ } else if (ts->nsec < 0) {
+ ts->nsec += NSEC_PER_SEC;
+ ts->sec--;
+ }
+ ts->sec += offset->sec;
+}
+
+/*
+ * Exported functions
+ */
+
+int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+{
+ int i = -1, err = 0, ret;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ if (try_id >= 0) {
+ if (pps_is_allocated(try_id)) {
+ pps_err("source id %d busy", try_id);
+ err = -EBUSY;
+ goto pps_register_source_exit;
+ }
+ i = try_id;
+ } else {
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (!pps_is_allocated(i))
+ break;
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("no free source ids");
+ err = -ENOMEM;
+ goto pps_register_source_exit;
+ }
+ }
+
+ /* Sanity checks */
+ if ((info->mode & default_params) != default_params) {
+ pps_err("unsupported default parameters");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+ info->echo == NULL) {
+ pps_err("echo function is not defined");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ pps_err("unspecified time format");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+
+ /* Allocate the PPS source.
+ *
+ * Note that we should reset all fields BUT "info" one! */
+ memset(&(pps_source[i].params), 0, sizeof(struct pps_kparams));
+ pps_source[i].params.api_version = PPS_API_VERS;
+ pps_source[i].params.mode = default_params;
+ pps_source[i].assert_sequence = 0;
+ pps_source[i].clear_sequence = 0;
+ pps_source[i].current_mode = 0;
+ pps_source[i].go = 0;
+ init_waitqueue_head(&pps_source[i].queue);
+
+ /* Allocate the PPS source */
+ pps_source[i].info = info;
+
+pps_register_source_exit :
+ mutex_unlock(&pps_mutex);
+
+ if (err < 0)
+ return err;
+
+ ret = pps_sysfs_create_source_entry(info, i);
+ if (ret < 0)
+ pps_err("unable to create sysfs entry for source %d", i);
+
+ return i;
+}
+EXPORT_SYMBOL(pps_register_source);
+
+void pps_unregister_source(struct pps_source_info_s *info)
+{
+ int i;
+
+ pps_sysfs_remove_source_entry(info);
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) && pps_source[i].info == info)
+ break;
+
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("warning! Try to unregister an unknow PPS source");
+ goto pps_unregister_source_exit;
+ }
+
+ /* Deallocate the PPS source */
+ pps_source[i].info = &dummy_info;
+
+pps_unregister_source_exit :
+ mutex_unlock(&pps_mutex);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+
+void pps_event(int source, int event, void *data)
+{
+ struct timespec __ts;
+ struct pps_ktime ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&__ts);
+
+ /* ... and translate it to PPS time data struct */
+ ts.sec = __ts.tv_sec;
+ ts.nsec = __ts.tv_nsec;
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
+ pps_err("unknow event (%x) for source %d", event, source);
+ return;
+ }
+
+ /* We wish not using locks at all into this function... a possible
+ * solution is to check the "info" field against the pointer to
+ * "dummy_info".
+ * If "info" points to "dummy_info" we can return doing nothing since,
+ * even if a new PPS source is registered by another CPU we can
+ * safely not register current event.
+ * If "info" points to a valid PPS source's info data we can continue
+ * without problem since, even if current PPS source is deregistered
+ * by another CPU, we still continue writing data into a valid area
+ * (dummy_info).
+ */
+ if (pps_source[source].info == &dummy_info)
+ return;
+
+ /* Must call the echo function? */
+ if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+ pps_source[source].info->echo(source, event, data);
+
+ /* Check the event */
+ pps_source[source].current_mode = pps_source[source].params.mode;
+ if (event & PPS_CAPTUREASSERT) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETASSERT)
+ pps_add_offset(&ts,
+ &pps_source[source].params.assert_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].assert_tu = ts;
+ pps_source[source].assert_sequence++;
+ pps_dbg("capture assert seq #%u for source %d",
+ pps_source[source].assert_sequence, source);
+ }
+ if (event & PPS_CAPTURECLEAR) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETCLEAR)
+ pps_add_offset(&ts,
+ &pps_source[source].params.clear_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].clear_tu = ts;
+ pps_source[source].clear_sequence++;
+ pps_dbg("capture clear seq #%u for source %d",
+ pps_source[source].clear_sequence, source);
+ }
+
+ pps_source[source].go = ~0;
+ wake_up_interruptible(&pps_source[source].queue);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 0000000..9134823
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,398 @@
+/*
+ * pps.c -- Main PPS support file
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/linkage.h>
+#include <linux/sched.h>
+#include <linux/pps.h>
+#include <linux/uaccess.h>
+
+/*
+ * Global variables
+ */
+
+struct pps_s pps_source[PPS_MAX_SOURCES];
+DEFINE_MUTEX(pps_mutex);
+
+void dummy_echo(int source, int event, void *data) { }
+struct pps_source_info_s dummy_info; /* Dummy PPS info for unallocated
+ PPS sources */
+
+/*
+ * Misc functions
+ */
+
+static inline int pps_check_source(int source)
+{
+ return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0;
+}
+
+static int pps_find_source(int source)
+{
+ int i;
+
+ if (source >= 0) {
+ if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source))
+ return -EINVAL;
+ else
+ return source;
+ }
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+static int pps_find_path(char *path)
+{
+ int i;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) &&
+ (strncmp(pps_source[i].info->path, path,
+ PPS_MAX_NAME_LEN) == 0 ||
+ strncmp(pps_source[i].info->name, path,
+ PPS_MAX_NAME_LEN) == 0))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+/*
+ * PPS System Calls
+ */
+
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg)
+{
+ struct pps_source_data_s data;
+ int ret = 0;
+
+ pps_dbg("%s: cmd %d", __FUNCTION__, cmd);
+
+ /* Sanity checks */
+ if (_IOC_TYPE(cmd) != 'P')
+ return -EOPNOTSUPP;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ switch (cmd) {
+ case PPS_CMD_FIND_SRC :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source);
+
+ data.source = pps_find_source(data.source);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ case PPS_CMD_FIND_PATH :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path);
+
+ data.source = pps_find_path(data.path);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ default :
+ pps_err("invalid sys_time_pps_cmd %d", cmd);
+ ret = -EOPNOTSUPP;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ /* Found! So copy the info */
+ strncpy(data.name, pps_source[data.source].info->name,
+ PPS_MAX_NAME_LEN);
+ strncpy(data.path, pps_source[data.source].info->path,
+ PPS_MAX_NAME_LEN);
+
+ ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_cmd_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params)
+{
+ int ret = 0;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getparams_exit;
+ }
+
+ /* Return current parameters */
+ ret = copy_to_user(params, &pps_source[source].params,
+ sizeof(struct pps_kparams));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_getparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Check the capabilities */
+ if (!capable(CAP_SYS_TIME))
+ return -EPERM;
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+ if ((params->mode & ~pps_source[source].info->mode) != 0) {
+ pps_dbg("unsupported capabilities");
+ return -EINVAL;
+ }
+ if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+ pps_dbg("capture mode unspecified");
+ return -EINVAL;
+ }
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Save the new parameters */
+ ret = copy_from_user(&pps_source[source].params, params,
+ sizeof(struct pps_kparams));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Restore the read only parameters */
+ if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ /* section 3.3 of RFC 2783 interpreted */
+ pps_dbg("time format unspecified");
+ pps_source[source].params.mode |= PPS_TSFMT_TSPEC;
+ }
+ if (pps_source[source].info->mode & PPS_CANWAIT)
+ pps_source[source].params.mode |= PPS_CANWAIT;
+ pps_source[source].params.api_version = PPS_API_VERS;
+
+sys_time_pps_setparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!mode)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getcap_exit;
+ }
+
+ ret = put_user(pps_source[source].info->mode, mode);
+
+sys_time_pps_getcap_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout)
+{
+ unsigned long ticks;
+ struct pps_kinfo pi;
+ struct pps_ktime to;
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ if (!info)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ pps_source[source].go = 0;
+
+ /* Manage the timeout */
+ if (timeout) {
+ ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime));
+ if (ret) {
+ goto sys_time_pps_fetch_exit;
+ ret = -EFAULT;
+ }
+ pps_dbg("timeout %lld.%09d", to.sec, to.nsec);
+ ticks = to.sec * HZ;
+ ticks += to.nsec / (NSEC_PER_SEC / HZ);
+
+ if (ticks != 0) {
+ ret = wait_event_interruptible_timeout(
+ pps_source[source].queue,
+ pps_source[source].go, ticks);
+ if (ret == 0) {
+ pps_dbg("timeout expired");
+ ret = -ETIMEDOUT;
+ goto sys_time_pps_fetch_exit;
+ }
+ }
+ } else
+ ret = wait_event_interruptible(pps_source[source].queue,
+ pps_source[source].go);
+
+ /* Check for pending signals */
+ if (ret == -ERESTARTSYS) {
+ pps_dbg("pending signal caught");
+ ret = -EINTR;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ /* Return the fetched timestamp */
+ pi.assert_sequence = pps_source[source].assert_sequence;
+ pi.clear_sequence = pps_source[source].clear_sequence;
+ pi.assert_tu = pps_source[source].assert_tu;
+ pi.clear_tu = pps_source[source].clear_tu;
+ pi.current_mode = pps_source[source].current_mode;
+ ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_fetch_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_exit(void)
+{
+ pps_sysfs_unregister();
+
+ pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS);
+}
+
+static int __init pps_init(void)
+{
+ int i, ret;
+
+ /* Init pps_source info */
+ dummy_info.echo = dummy_echo;
+ for (i = 0; i < PPS_MAX_SOURCES; i++) {
+ pps_source[i].info = &dummy_info;
+ init_waitqueue_head(&pps_source[i].queue);
+ }
+
+ /* Register to sysfs */
+ ret = pps_sysfs_register();
+ if (ret < 0) {
+ pps_err("unable to register sysfs");
+ return ret;
+ }
+
+ pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS);
+ pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+ "<giometti@linux.it>", PPS_VERSION);
+
+ return 0;
+}
+
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
new file mode 100644
index 0000000..e52dd8e
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,217 @@
+/*
+ * sysfs.c -- sysfs support
+ *
+ *
+ * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/device.h>
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <linux/pps.h>
+
+/*
+ * Private functions
+ */
+
+static ssize_t pps_show_assert(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->assert_tu.sec, dev->assert_tu.nsec,
+ dev->assert_sequence);
+}
+
+static ssize_t pps_show_clear(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->clear_tu.sec, dev->clear_tu.nsec,
+ dev->clear_sequence);
+}
+
+static ssize_t pps_show_mode(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%4x\n", info->mode);
+}
+
+static ssize_t pps_show_echo(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%d\n", !!info->echo);
+}
+
+static ssize_t pps_show_name(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->name);
+}
+
+static ssize_t pps_show_path(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->path);
+}
+
+/*
+ * Files definitions
+ */
+
+#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \
+{ \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = _mode, \
+ .owner = THIS_MODULE, \
+ }, \
+ .show = _show, \
+ .store = _store, \
+}
+
+static struct class_device_attribute pps_class_device_attributes[] = {
+ DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL),
+ DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL),
+ DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL),
+ DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL),
+ DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL),
+ DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL),
+};
+
+/*
+ * Class definitions
+ */
+
+static void pps_class_release(struct class_device *cdev)
+{
+ /* Nop??? */
+}
+
+static struct class pps_class = {
+ .name = "pps",
+ .release = pps_class_release,
+};
+
+/*
+ * Public functions
+ */
+
+void pps_sysfs_remove_source_entry(struct pps_source_info_s *info)
+{
+ int i;
+
+ /* Sanity checks */
+ if (info == NULL)
+ return;
+
+ /* Delete info files */
+ if (info->mode&PPS_CAPTUREASSERT)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+
+ if (info->mode&PPS_CAPTURECLEAR)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ /* Deregister the pps class */
+ class_device_unregister(&info->class_dev);
+}
+
+int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id)
+{
+ char buf[32];
+ int i, ret;
+
+ /* Sanity checks */
+ if (info == NULL || id >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ /* Create dir class device name */
+ sprintf(buf, "%.02d", id);
+
+ /* Setup the class struct */
+ memset(&info->class_dev, 0, sizeof(struct class_device));
+ info->class_dev.class = &pps_class;
+ strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN);
+ class_set_devdata(&info->class_dev, &pps_source[id]);
+
+ /* Register the new class */
+ ret = class_device_register(&info->class_dev);
+ if (unlikely(ret))
+ goto error_class_device_register;
+
+ /* Create info files */
+
+ /* Create file "assert" and "clear" according to source capability */
+ if (info->mode & PPS_CAPTUREASSERT) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+ i = 0;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+ if (info->mode & PPS_CAPTURECLEAR) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+ i = 1;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ return 0;
+
+error_class_device_create_file:
+ while (--i >= 0)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ class_device_unregister(&info->class_dev);
+ /* Here the release() method was already called */
+
+error_class_device_register:
+
+ return ret;
+}
+
+void pps_sysfs_unregister(void)
+{
+ class_unregister(&pps_class);
+}
+
+int pps_sysfs_register(void)
+{
+ return class_register(&pps_class);
+}
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c84dab0..0c9a307 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
up->ier |= UART_IER_MSI;
if (up->capabilities & UART_CAP_UUE)
up->ier |= UART_IER_UUE | UART_IER_RTOIE;
+ if (up->port.flags & UPF_HARDPPS_CD)
+ up->ier |= UART_IER_MSI; /* enable interrupts */
serial_out(up, UART_IER, up->ier);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 326020f..bd12165 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -33,6 +33,7 @@
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
#include <linux/delay.h>
#include <linux/mutex.h>
+#include <linux/pps.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
@@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state,
return 0;
}
+#ifdef CONFIG_PPS_CLIENT_UART
+
+static int
+uart_register_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ struct tty_driver *drv = port->info->tty->driver;
+ int ret;
+
+ snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d",
+ drv->driver_name, port->line);
+ snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d",
+ drv->name, port->line);
+
+ state->pps_info.mode = PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR,
+ -1 /* PPS ID is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register PPS source \"%s\"",
+ state->pps_info.path);
+ return ret;
+ }
+ port->pps_source = ret;
+ pps_info("PPS source #%d \"%s\" added to the system ",
+ port->pps_source, state->pps_info.path);
+
+ return 0;
+}
+
+static void
+uart_unregister_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ pps_unregister_source(&state->pps_info);
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, state->pps_info.path);
+}
+
+#else
+
+#define uart_register_pps_port(state, port) do { } while (0)
+#define uart_unregister_pps_port(state, port) do { } while (0)
+
+#endif /* CONFIG_PPS_CLIENT_UART */
+
static int uart_set_info(struct uart_state *state,
struct serial_struct __user *newinfo)
{
@@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state,
(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
check_and_exit:
+ /* PPS support enabled/disabled? */
+ if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) {
+ if (new_flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+ else
+ uart_unregister_pps_port(state, port);
+ }
+
retval = 0;
if (port->type == PORT_UNKNOWN)
goto exit;
if (state->info->flags & UIF_INITIALIZED) {
- if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
+ if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) ||
old_custom_divisor != port->custom_divisor) {
/*
* If they're setting up a custom divisor or speed,
@@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
port->ops->config_port(port, flags);
}
+ /*
+ * Add the PPS support for the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+
if (port->type != PORT_UNKNOWN) {
unsigned long flags;
@@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
mutex_unlock(&state->mutex);
/*
+ * Remove PPS support from the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_unregister_pps_port(state, port);
+
+ /*
* Remove the devices from the tty layer
*/
tty_unregister_device(drv->tty_driver, port->line);
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index e84ace1..36746dc 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -329,10 +329,15 @@
#define __NR_signalfd 321
#define __NR_timerfd 322
#define __NR_eventfd 323
+#define __NR_time_pps_cmd 324
+#define __NR_time_pps_getparams 325
+#define __NR_time_pps_setparams 326
+#define __NR_time_pps_getcap 327
+#define __NR_time_pps_fetch 328
#ifdef __KERNEL__
-#define NR_syscalls 324
+#define NR_syscalls 329
#define __ARCH_WANT_IPC_PARSE_VERSION
#define __ARCH_WANT_OLD_READDIR
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index f317c27..a10d20a 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -293,6 +293,7 @@ unifdef-y += pmu.h
unifdef-y += poll.h
unifdef-y += ppp_defs.h
unifdef-y += ppp-comp.h
+unifdef-y += pps.h
unifdef-y += ptrace.h
unifdef-y += qnx4_fs.h
unifdef-y += quota.h
diff --git a/include/linux/parport.h b/include/linux/parport.h
index 9cdd694..f53d9f4 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -100,6 +100,7 @@ typedef enum {
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
+#include <linux/pps.h>
#include <asm/system.h>
#include <asm/ptrace.h>
#include <asm/semaphore.h>
@@ -327,6 +328,11 @@ struct parport {
struct list_head full_list;
struct parport *slaves[3];
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ struct pps_source_info_s pps_info;
+ int pps_source; /* PPS source ID */
+#endif
};
#define DEFAULT_SPIN_TIME 500 /* us */
@@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode);
/* Lowlevel drivers _can_ call this support function to handle irqs. */
static __inline__ void parport_generic_irq(int irq, struct parport *port)
{
+#ifdef CONFIG_PPS_CLIENT_LP
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("parport_pc: PPS assert event at %lu on source #%d",
+ jiffies, port->pps_source);
+#endif
+
parport_ieee1284_interrupt (irq, port);
read_lock(&port->cad_lock);
if (port->cad && port->cad->irq_func)
diff --git a/include/linux/pps.h b/include/linux/pps.h
new file mode 100644
index 0000000..f22c299
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,207 @@
+/*
+ * pps.h -- PPS API kernel header.
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+
+#ifndef _PPS_H_
+#define _PPS_H_
+
+/* Implementation note: the logical states ``assert'' and ``clear''
+ * are implemented in terms of the chip register, i.e. ``assert''
+ * means the bit is set. */
+
+/*
+ * 3.2 New data structures
+ */
+
+#ifndef __KERNEL__
+#include <linux/types.h>
+#include <sys/time.h>
+#else
+#include <linux/time.h>
+#endif
+
+#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */
+#define PPS_API_VERS PPS_API_VERS_2
+#define LINUXPSS_API 1 /* mark LinuxPPS API */
+
+#define PPS_MAX_NAME_LEN 32
+
+struct pps_ktime {
+ __u64 sec;
+ __u32 nsec;
+};
+
+struct pps_kinfo {
+ __u32 assert_sequence; /* seq. num. of assert event */
+ __u32 clear_sequence; /* seq. num. of clear event */
+ struct pps_ktime assert_tu; /* time of assert event */
+ struct pps_ktime clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_kparams {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ struct pps_ktime assert_off_tu; /* offset compensation for assert */
+ struct pps_ktime clear_off_tu; /* offset compensation for clear */
+};
+
+/*
+ * 3.3 Mode bit definitions
+ */
+
+/* Device/implementation parameters */
+#define PPS_CAPTUREASSERT 0x01 /* capture assert events */
+#define PPS_CAPTURECLEAR 0x02 /* capture clear events */
+#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
+
+#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
+#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
+
+#define PPS_CANWAIT 0x100 /* can we wait for an event? */
+#define PPS_CANPOLL 0x200 /* bit reserved for future use */
+
+/* Kernel actions */
+#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
+#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
+
+/* Timestamp formats */
+#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
+#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
+
+/*
+ * 3.4.4 New functions: disciplining the kernel timebase
+ */
+
+/* Kernel consumers */
+#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */
+#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to
+ use a phase-locked loop */
+#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to
+ use a frequency-locked loop */
+/*
+ * Here begins the implementation-specific part!
+ */
+
+#include <linux/ioctl.h>
+
+struct pps_source_data_s {
+ int source;
+ char name[PPS_MAX_NAME_LEN];
+ char path[PPS_MAX_NAME_LEN];
+};
+
+#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *)
+#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *)
+
+#ifdef __KERNEL__
+
+#include <linux/device.h>
+
+/*
+ * Misc macros
+ */
+
+#define PPS_VERSION "4.0.0-rc4"
+
+#ifdef CONFIG_PPS_DEBUG
+#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#else
+#define pps_dbg(format, arg...) do {} while (0)
+#endif
+
+#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+
+/*
+ * Global defines
+ */
+
+#define PPS_MAX_SOURCES 16
+
+/* The specific PPS source info */
+struct pps_source_info_s {
+ char name[PPS_MAX_NAME_LEN]; /* simbolic name */
+ char path[PPS_MAX_NAME_LEN]; /* path of connected device */
+ int mode; /* PPS's allowed mode */
+
+ void (*echo)(int source, int event, void *data); /* PPS echo function */
+
+ /* sysfs section */
+ struct class_device class_dev;
+};
+
+/* The main struct */
+struct pps_s {
+ struct pps_source_info_s *info; /* PSS source info */
+
+ struct pps_kparams params; /* PPS's current params */
+
+ volatile __u32 assert_sequence; /* PPS' assert event seq # */
+ volatile __u32 clear_sequence; /* PPS' clear event seq # */
+ volatile struct pps_ktime assert_tu;
+ volatile struct pps_ktime clear_tu;
+ int current_mode; /* PPS mode at event time */
+
+ int go; /* PPS event is arrived? */
+ wait_queue_head_t queue; /* PPS event queue */
+};
+
+/*
+ * Global variables
+ */
+
+extern struct pps_s pps_source[PPS_MAX_SOURCES];
+extern struct mutex pps_mutex;
+extern struct pps_source_info_s dummy_info;
+
+/*
+ * Global functions
+ */
+
+static inline int pps_is_allocated(int source)
+{
+ return pps_source[source].info != &dummy_info;
+}
+
+#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev)
+
+/*
+ * Exported functions
+ */
+
+extern int pps_register_source(struct pps_source_info_s *info,
+ int default_params, int try_id);
+extern void pps_unregister_source(struct pps_source_info_s *info);
+extern void pps_event(int source, int event, void *data);
+
+extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info,
+ int id);
+extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info);
+extern int pps_sysfs_register(void);
+extern void pps_sysfs_unregister(void);
+
+#endif /* __KERNEL__ */
+
+#endif /* _PPS_H_ */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 7f2c99d..654ad19 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -153,6 +153,7 @@
#include <linux/tty.h>
#include <linux/mutex.h>
#include <linux/sysrq.h>
+#include <linux/pps.h>
struct uart_port;
struct uart_info;
@@ -232,6 +233,9 @@ struct uart_port {
unsigned char regshift; /* reg offset shift */
unsigned char iotype; /* io access style */
unsigned char unused1;
+#ifdef CONFIG_PPS_CLIENT_UART
+ int pps_source; /* PPS source ID */
+#endif
#define UPIO_PORT (0)
#define UPIO_HUB6 (1)
@@ -276,7 +280,8 @@ struct uart_port {
#define UPF_IOREMAP ((__force upf_t) (1 << 31))
#define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))
-#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
+#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\
+ |UPF_HARDPPS_CD))
unsigned int mctrl; /* current modem ctrl settings */
unsigned int timeout; /* character-based timeout */
@@ -308,6 +313,10 @@ struct uart_state {
struct uart_info *info;
struct uart_port *port;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct pps_source_info_s pps_info;
+#endif
+
struct mutex mutex;
};
@@ -472,13 +481,26 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
- port->icount.dcd++;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct tty_driver *drv = port->info->tty->driver;
-#ifdef CONFIG_HARD_PPS
- if ((port->flags & UPF_HARDPPS_CD) && status)
- hardpps();
+ if (port->flags & UPF_HARDPPS_CD) {
+ if (status) {
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("%s%d: PPS assert event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ } else {
+ pps_event(port->pps_source, PPS_CAPTURECLEAR, port);
+ pps_dbg("%s%d: PPS clear event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ }
+ }
#endif
+ port->icount.dcd++;
+
if (info->flags & UIF_CHECK_CD) {
if (status)
wake_up_interruptible(&info->open_wait);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 83d0ec1..bfc8899 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -65,6 +65,7 @@ struct getcpu_cache;
#include <asm/signal.h>
#include <linux/quota.h>
#include <linux/key.h>
+#include <linux/pps.h>
asmlinkage long sys_time(time_t __user *tloc);
asmlinkage long sys_stime(time_t __user *tptr);
@@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags,
const struct itimerspec __user *utmr);
asmlinkage long sys_eventfd(unsigned int count);
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg);
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode);
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout);
+
int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 7e11e2c..e0fccc2 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -148,3 +148,10 @@ cond_syscall(sys_timerfd);
cond_syscall(compat_sys_signalfd);
cond_syscall(compat_sys_timerfd);
cond_syscall(sys_eventfd);
+
+/* PPS dependent */
+cond_syscall(sys_time_pps_find);
+cond_syscall(sys_time_pps_getparams);
+cond_syscall(sys_time_pps_setparams);
+cond_syscall(sys_time_pps_getcap);
+cond_syscall(sys_time_pps_fetch);
^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 8:00 ` Rodolfo Giometti
@ 2007-07-24 13:49 ` David Woodhouse
2007-07-24 14:20 ` Rodolfo Giometti
2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti
0 siblings, 2 replies; 43+ messages in thread
From: David Woodhouse @ 2007-07-24 13:49 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton
On Tue, 2007-07-24 at 10:00 +0200, Rodolfo Giometti wrote:
> On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote:
> >
> > s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt
>
> Fixed.
Also 's/unknow /unknown /' (2 instances)
> > Please feed it to scripts/checkpatch.pl -- you can ignore all the
> > warnings about lines greater than 80 characters, and the complete crap
> > about "declaring multiple variables together should be avoided", but
>
> Done. Most fixed.
Looks better.
> > some of what it points out is valid. Including the one about 'volatile'
> > -- your explanation lacked credibility. If you really need 'volatile'
> > then put it at the places you actually need it; not the declaration of
> > the structure.
>
> Can you please explain better where should I put the 'volatile'
> attribute? :-o
Am I right in thinking that the only place it matters is within
pps_event()? In that case, at the very least you should probably remove
the 'volatile' from the definition of the structure, and _cast_ to
volatile where you want it treated that way.
But I don't see why you can't protect it with a spinlock. As long as you
acquire that spinlock _after_ your call to getnstimeofday() what's the
problem?
> > ...
> This should be not needed due new 'struct pps_ktime'.
> > ...
> These typedefs are into timepps.h which is an userland file (located
> into Documentation/pps/) and are requested by the RFC.
Sorry, yes. I shouldn't have been looking at that as if it was kernel
code.
I think you still haven't quite got the 32-bit vs. 64-bit compatibility
right. Remember that on i386, the alignment of a uint64_t is only 4
bytes, while on most other architectures it's 8 bytes. On i386, there
will be no padding between the two consecutive 'struct pps_ktime'
members of struct pps_kinfo and struct pps_kparams. But on most
platforms there will be padding to ensure correct alignment.
The simple fix is probably to make the 'nsec' member a 64-bit integer
too. Then it'll be the same for i386 and x86_64 and you won't need a
compatibility syscall routine.
In order for your handling of 'pps_source[source].info' to be safe with
respect to pps_unregister_source(), you have to guarantee that
pps_event() has finished -- and can't be in progress on another CPU --
by the time your client's call to pps_unregister_source() completes. At
first glance I think your existing clients have that right (you have
del_timer_sync() before pps_unregister_source() in ktimer.c, for
example). But you should make sure it's clearly documented for new
clients.
Shouldn't your PPS_CLIENT_LP and PPS_CLIENT_UART options depend on
PARPORT and SERIAL_CORE respectively?
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 13:49 ` David Woodhouse
@ 2007-07-24 14:20 ` Rodolfo Giometti
2007-07-24 14:46 ` David Woodhouse
2007-07-24 14:52 ` David Woodhouse
2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti
1 sibling, 2 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-24 14:20 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote:
> Also 's/unknow /unknown /' (2 instances)
?? I didn't find them:
$ grep 'unknow ' Documentation/pps/pps.txt
> Am I right in thinking that the only place it matters is within
> pps_event()? In that case, at the very least you should probably remove
> the 'volatile' from the definition of the structure, and _cast_ to
> volatile where you want it treated that way.
Ok, I see.
> But I don't see why you can't protect it with a spinlock. As long as you
> acquire that spinlock _after_ your call to getnstimeofday() what's the
> problem?
The problem is that we can have several PPS sources into a system and
all these sources will arise their IRQ line (quasi)simultaneously and
I don't wish a CPU may delay one of these IRQ handler due a spinlock
into the pps_event().
That's why I'm trying to avoid any lock into pps_event().
> I think you still haven't quite got the 32-bit vs. 64-bit compatibility
> right. Remember that on i386, the alignment of a uint64_t is only 4
> bytes, while on most other architectures it's 8 bytes. On i386, there
> will be no padding between the two consecutive 'struct pps_ktime'
> members of struct pps_kinfo and struct pps_kparams. But on most
> platforms there will be padding to ensure correct alignment.
>
> The simple fix is probably to make the 'nsec' member a 64-bit integer
> too. Then it'll be the same for i386 and x86_64 and you won't need a
> compatibility syscall routine.
Ok. I'll add your comment too.
> In order for your handling of 'pps_source[source].info' to be safe with
> respect to pps_unregister_source(), you have to guarantee that
> pps_event() has finished -- and can't be in progress on another CPU --
> by the time your client's call to pps_unregister_source() completes. At
> first glance I think your existing clients have that right (you have
> del_timer_sync() before pps_unregister_source() in ktimer.c, for
> example). But you should make sure it's clearly documented for new
> clients.
This can be done only with locks, but it's not necessary since even if
a pps_unregister_source() runs while pps_event() executes on another
CPU the latter will write always on a valid area (even if it could be
a dummy one) and the data are not corrupted (note also that the data
will be, in any case, discarted since we are executing a
pps_unregister_source()).
> Shouldn't your PPS_CLIENT_LP and PPS_CLIENT_UART options depend on
> PARPORT and SERIAL_CORE respectively?
No. These options can be enabled but if no serial/parallel driver is
loaded no PPS source is registered.
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 13:49 ` David Woodhouse
2007-07-24 14:20 ` Rodolfo Giometti
@ 2007-07-24 14:31 ` Rodolfo Giometti
2007-07-24 14:45 ` David Woodhouse
2007-07-26 19:52 ` Roman Zippel
1 sibling, 2 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-24 14:31 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote:
>
> I think you still haven't quite got the 32-bit vs. 64-bit compatibility
> right. Remember that on i386, the alignment of a uint64_t is only 4
> bytes, while on most other architectures it's 8 bytes. On i386, there
> will be no padding between the two consecutive 'struct pps_ktime'
> members of struct pps_kinfo and struct pps_kparams. But on most
> platforms there will be padding to ensure correct alignment.
>
> The simple fix is probably to make the 'nsec' member a 64-bit integer
> too. Then it'll be the same for i386 and x86_64 and you won't need a
> compatibility syscall routine.
By doing:
struct pps_ktime {
__u64 sec;
- __u32 nsec;
+ __u64 nsec;
};
I got:
GEN .version
CHK include/linux/compile.h
UPD include/linux/compile.h
CC init/version.o
LD init/built-in.o
LD .tmp_vmlinux1
drivers/built-in.o: In function `sys_time_pps_fetch':
(.text+0x5f05e): undefined reference to `__udivdi3'
make: *** [.tmp_vmlinux1] Error 1
I suppose the problem is here:
ticks = to.sec * HZ;
ticks += to.nsec / (NSEC_PER_SEC / HZ);
Suggestions? :)
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti
@ 2007-07-24 14:45 ` David Woodhouse
2007-07-24 16:09 ` Rodolfo Giometti
2007-07-26 19:52 ` Roman Zippel
1 sibling, 1 reply; 43+ messages in thread
From: David Woodhouse @ 2007-07-24 14:45 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton
On Tue, 2007-07-24 at 16:31 +0200, Rodolfo Giometti wrote:
> drivers/built-in.o: In function `sys_time_pps_fetch':
> (.text+0x5f05e): undefined reference to `__udivdi3'
Hm, not sure. Maybe put it back to uint32_t and then add another
uint32_t of explicit padding, or maybe just cast it to uint32_t when you
divide:
ticks += (uint32_t)to.nsec / (NSEC_PER_SEC/HZ);
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:20 ` Rodolfo Giometti
@ 2007-07-24 14:46 ` David Woodhouse
2007-07-24 14:52 ` David Woodhouse
1 sibling, 0 replies; 43+ messages in thread
From: David Woodhouse @ 2007-07-24 14:46 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton
On Tue, 2007-07-24 at 16:20 +0200, Rodolfo Giometti wrote:
> The problem is that we can have several PPS sources into a system and
> all these sources will arise their IRQ line (quasi)simultaneously and
> I don't wish a CPU may delay one of these IRQ handler due a spinlock
> into the pps_event().
>
> That's why I'm trying to avoid any lock into pps_event().
The spinlock really wouldn't be held for long. It really shouldn't be a
problem, and it shouldn't hold up your timings at all. And presumably
you'd have a _different_ spinlock for each source, so they wouldn't
stomp on each other at all.
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:20 ` Rodolfo Giometti
2007-07-24 14:46 ` David Woodhouse
@ 2007-07-24 14:52 ` David Woodhouse
2007-07-24 16:01 ` Rodolfo Giometti
2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti
1 sibling, 2 replies; 43+ messages in thread
From: David Woodhouse @ 2007-07-24 14:52 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton
On Tue, 2007-07-24 at 16:20 +0200, Rodolfo Giometti wrote:
> On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote:
>
> > Also 's/unknow /unknown /' (2 instances)
>
> ?? I didn't find them:
>
> $ grep 'unknow ' Documentation/pps/pps.txt
Elsewhere in the patch.
> > In order for your handling of 'pps_source[source].info' to be safe with
> > respect to pps_unregister_source(), you have to guarantee that
> > pps_event() has finished -- and can't be in progress on another CPU --
> > by the time your client's call to pps_unregister_source() completes. At
> > first glance I think your existing clients have that right (you have
> > del_timer_sync() before pps_unregister_source() in ktimer.c, for
> > example). But you should make sure it's clearly documented for new
> > clients.
>
> This can be done only with locks, but it's not necessary since even if
> a pps_unregister_source() runs while pps_event() executes on another
> CPU the latter will write always on a valid area (even if it could be
> a dummy one) and the data are not corrupted (note also that the data
> will be, in any case, discarted since we are executing a
> pps_unregister_source()).
Read Documentation/memory-barriers.txt
There is a tiny but possibly non-zero chance that one CPU could be in
pps_event() and might not yet have 'seen' the change to the .info field.
Releasing the pps_mutex provides a write-barrier on the CPU which runs
pps_unregister_source(), but there's no corresponding read-barrier on
the CPU running pps_event(). You have to be careful about when
pps_event() is run. It _MUST_ not touch the old info structure after
pps_unregister_source() has completed.
At the moment, I think it's OK because you won't be calling pps_event()
at the wrong times. But you do need to make sure that requirement is
documented. And I think you can remove the whole dummy_info thing
because it's not necessary.
--
dwmw2
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:52 ` David Woodhouse
@ 2007-07-24 16:01 ` Rodolfo Giometti
2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti
1 sibling, 0 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-24 16:01 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
[-- Attachment #1: Type: text/plain, Size: 1286 bytes --]
On Tue, Jul 24, 2007 at 03:52:49PM +0100, David Woodhouse wrote:
>
> Elsewhere in the patch.
Got, thanks.
> Read Documentation/memory-barriers.txt
>
> There is a tiny but possibly non-zero chance that one CPU could be in
> pps_event() and might not yet have 'seen' the change to the .info field.
> Releasing the pps_mutex provides a write-barrier on the CPU which runs
> pps_unregister_source(), but there's no corresponding read-barrier on
> the CPU running pps_event(). You have to be careful about when
> pps_event() is run. It _MUST_ not touch the old info structure after
> pps_unregister_source() has completed.
>
> At the moment, I think it's OK because you won't be calling pps_event()
> at the wrong times. But you do need to make sure that requirement is
> documented. And I think you can remove the whole dummy_info thing
> because it's not necessary.
What about this new solution involving tasklets? The pps_event() now
just records data and then a tasklet do the data management job. :)
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
[-- Attachment #2: proposed_patch --]
[-- Type: text/plain, Size: 68780 bytes --]
diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
new file mode 100644
index 0000000..a2660a2
--- /dev/null
+++ b/Documentation/pps/Makefile
@@ -0,0 +1,27 @@
+TARGETS = ppstest ppsctl
+
+CFLAGS += -Wall -O2 -D_GNU_SOURCE
+CFLAGS += -I .
+CFLAGS += -ggdb
+
+# -- Actions section ----------------------------------------------------------
+
+.PHONY : all depend dep
+
+all : .depend $(TARGETS)
+
+.depend depend dep :
+ $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
+
+
+# -- Clean section ------------------------------------------------------------
+
+.PHONY : clean
+
+clean :
+ rm -f *.o *~ core .depend
+ rm -f ${TARGETS}
diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
new file mode 100644
index 0000000..511fa36
--- /dev/null
+++ b/Documentation/pps/pps.txt
@@ -0,0 +1,211 @@
+
+ PPS - Pulse Per Second
+ ----------------------
+
+(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com>
+
+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.
+
+
+
+Overview
+--------
+
+LinuxPPS provides a programming interface (API) to define into the
+system several PPS sources.
+
+PPS means "pulse per second" and a PPS source is just a device which
+provides a high precision signal each second so that an application
+can use it to adjust system clock time.
+
+A PPS source can be connected to a serial port (usually to the Data
+Carrier Detect pin) or to a parallel port (ACK-pin) or to a special
+CPU's GPIOs (this is the common case in embedded systems) but in each
+case when a new pulse comes the system must apply to it a timestamp
+and record it for the userland.
+
+Common use is the combination of the NTPD as userland program with a
+GPS receiver as PPS source to obtain a wallclock-time with
+sub-millisecond synchronisation to UTC.
+
+
+RFC considerations
+------------------
+
+While implementing a PPS API as RFC 2783 defines and using an embedded
+CPU GPIO-Pin as physical link to the signal, I encountered a deeper
+problem:
+
+ At startup it needs a file descriptor as argument for the function
+ time_pps_create().
+
+This implies that the source has a /dev/... entry. This assumption is
+ok for the serial and parallel port, where you can do something
+useful besides(!) the gathering of timestamps as it is the central
+task for a PPS-API. But this assumption does not work for a single
+purpose GPIO line. In this case even basic file-related functionality
+(like read() and write()) makes no sense at all and should not be a
+precondition for the use of a PPS-API.
+
+The problem can be simply solved if you change the original RFC 2783:
+
+ pps_handle_t type is an opaque __scalar type__ used to represent a
+ PPS source within the API
+
+into a modified:
+
+ pps_handle_t type is an opaque __variable__ used to represent a PPS
+ source within the API and programs should not access it directly to
+ it due to its opacity.
+
+This change seems to be neglibile because even the original RFC 2783
+does not encourage programs to check (read: use) the pps_handle_t
+variable before calling the time_pps_*() functions, since each
+function should do this job internally.
+
+If I intentionally separate the concept of "file descriptor" from the
+concept of the "PPS source" I'm obliged to provide a solution to find
+and register a PPS-source without using a file descriptor: it's done
+by the functions time_pps_findsource() and time_pps_findpath() now.
+
+According to this current NTPD drivers' code should be modified as
+follows:
+
++#ifdef PPS_HAVE_FINDPATH
++ /* Get the PPS source's real name */
++ fd = readlink(link, path, STRING_LEN-1);
++ if (fd <= 0)
++ strncpy(path, link, STRING_LEN);
++ else
++ path[fd] = '\0';
++
++ /* Try to find the source */
++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
++ if (fd < 0) {
++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" "
++ "in the system", path);
++ return 1;
++ }
++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"",
++ fd, path, id);
++#endif /* PPS_HAVE_FINDPATH */
++
++
+ if (time_pps_create(fd, &pps_handle) < 0) {
+- pps_handle = 0;
+ msyslog(LOG_ERR, "refclock: time_pps_create failed: %m");
+ }
+
+
+Coding example
+--------------
+
+To register a PPS source into the kernel you should define a struct
+pps_source_info_s as follow:
+
+ static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+ };
+
+and then calling the function pps_register_source() in your
+intialization routine as follow:
+
+ source = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+
+The pps_register_source() prototype is:
+
+ int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+
+where "info" is a pointer to a structure that describes a particular
+PPS source, "default_params" tells the system what the initial default
+parameters for the device should be (is obvious that these parameters
+must be a subset of ones defined into the struct
+pps_source_info_s which describe the capabilities of the driver)
+and "try_id" can be used to force a particular ID for your device into
+the system (just use -1 if you wish the system chooses one for you).
+
+Once you have registered a new PPS source into the system you can
+signal an assert event (for example in the interrupt handler routine)
+just using:
+
+ pps_event(source, PPS_CAPTUREASSERT, ptr);
+
+The same function may also run the defined echo function
+(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user
+asked for that... etc..
+
+Please see the file drivers/pps/clients/ktimer.c for an example code.
+
+
+SYSFS support
+-------------
+
+The SYSFS support is enabled by default if the SYSFS filesystem is
+enabled in the kernel and it provides a new class:
+
+ $ ls /sys/class/pps/
+ 00/ 01/ 02/
+
+Every directory is the ID of a PPS sources defined into the system and
+inside you find several files:
+
+ $ ls /sys/class/pps/00/
+ assert clear echo mode name path subsystem@ uevent
+
+Inside each "assert" and "clear" file you can find the timestamp and a
+sequence number:
+
+ $ cat /sys/class/pps/00/assert
+ 1170026870.983207967#8
+
+Where before the "#" is the timestamp in seconds and after it is the
+sequence number. Other files are:
+
+* echo: reports if the PPS source has an echo function or not;
+
+* mode: reports available PPS functioning modes;
+
+* name: reports the PPS source's name;
+
+* path: reports the PPS source's device path, that is the device the
+ PPS source is connected to (if it exists).
+
+
+Testing the PPS support
+-----------------------
+
+In order to test the PPS support even without specific hardware you can use
+the ktimer driver (see the client subsection in the PPS configuration menu)
+and the userland tools provided into Documentaion/pps/ directory.
+
+Once you have enabled the compilation of ktimer just modprobe it (if
+not statically compiled):
+
+ # modprobe ktimer
+
+and the run ppstest as follow:
+
+ $ ./ppstest
+ found PPS source #0 "ktimer" on ""
+ ok, found 1 source(s), now start fetching data...
+ source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0
+ source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0
+
+Please, note that to compile userland programs you need the file timepps.h
+(see Documentation/pps/).
diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c
new file mode 100644
index 0000000..17afcbd
--- /dev/null
+++ b/Documentation/pps/ppsctl.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/serial.h>
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);
+
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd, ret;
+ struct serial_struct ss;
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0) {
+ perror("open");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCGSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCGSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ if (argc < 3) { /* just read PPS status */
+ printf("PPS is %sabled\n",
+ ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");
+ exit(EXIT_SUCCESS);
+ }
+
+ if (argv[2][0] == 'e' || argv[2][0] == '1')
+ ss.flags |= ASYNC_HARDPPS_CD;
+ else if (argv[2][0] == 'd' || argv[2][0] == '0')
+ ss.flags &= ~ASYNC_HARDPPS_CD;
+ else {
+ fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCSSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCSSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
new file mode 100644
index 0000000..bfd1064
--- /dev/null
+++ b/Documentation/pps/ppstest.c
@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <timepps.h>
+
+#define STRING_LEN PPS_MAX_NAME_LEN
+
+int find_source(int try_link, char *link, pps_handle_t *handle,
+ int *avail_mode)
+{
+ int num = -1;
+ char id[STRING_LEN] = "", /* no ID string by default */
+ path[STRING_LEN];
+ pps_params_t params;
+ int ret;
+
+ if (try_link) {
+ printf("trying PPS source \"%s\"\n", link);
+#ifdef PPS_HAVE_FINDPATH
+ /* Get the PPS source's real name */
+ time_pps_readlink(link, STRING_LEN, path, STRING_LEN);
+
+ /* Try to find the source by using the supplied "path" name */
+ ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
+ if (ret < 0)
+ goto exit;
+ num = ret;
+#else
+#warning "cannot use time_pps_findpath()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDPATH */
+ }
+#ifdef PPS_HAVE_FINDSOURCE
+ /* Try to find the source (by using "index = -1" we ask just
+ * for a generic source) */
+ ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN);
+#else
+#warning "cannot use time_pps_findsource()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDSOURCE */
+ if (ret < 0) {
+exit:
+ fprintf(stderr, "no available PPS source in the system\n");
+ return -1;
+ }
+ num = ret;
+ printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path);
+
+ /* If "path" is not NULL we should *at least* open the pointed
+ * device in order to enable the interrupts generation.
+ * Note that this can be NOT enough anyway, infact you may need sending
+ * additional commands to your GPS antenna before it starts sending
+ * the PPS signal. */
+ if (strlen(path)) {
+ ret = open(path, O_RDWR);
+ if (ret < 0) {
+ fprintf(stderr, "cannot open \"%s\" (%m)\n", path);
+ return -1;
+ }
+ }
+
+ /* Open the PPS source */
+ ret = time_pps_create(num, handle);
+ if (ret < 0) {
+ fprintf(stderr, "cannot create a PPS source (%m)\n");
+ return -1;
+ }
+
+ /* Find out what features are supported */
+ ret = time_pps_getcap(*handle, avail_mode);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get capabilities (%m)\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
+ fprintf(stderr, "cannot CAPTUREASSERT\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_OFFSETASSERT) == 0) {
+ fprintf(stderr, "cannot OFFSETASSERT\n");
+ return -1;
+ }
+
+ /* Capture assert timestamps, and compensate for a 675 nsec
+ * propagation delay */
+ ret = time_pps_getparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get parameters (%m)\n");
+ return -1;
+ }
+ params.assert_offset.tv_sec = 0;
+ params.assert_offset.tv_nsec = 675;
+ params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT;
+ ret = time_pps_setparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot set parameters (%m)\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fetch_source(int i, pps_handle_t *handle, int *avail_mode)
+{
+ struct timespec timeout;
+ pps_info_t infobuf;
+ int ret;
+
+ /* create a zero-valued timeout */
+ timeout.tv_sec = 3;
+ timeout.tv_nsec = 0;
+
+retry:
+ if (*avail_mode & PPS_CANWAIT) {
+ /* waits for the next event */
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ } else {
+ sleep(1);
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ }
+ if (ret < 0) {
+ if (ret == -EINTR) {
+ fprintf(stderr, "time_pps_fetch() got a signal!\n");
+ goto retry;
+ }
+
+ fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);
+ return -1;
+ }
+
+ printf("source %d - "
+ "assert %ld.%09ld, sequence: %ld - "
+ "clear %ld.%09ld, sequence: %ld\n",
+ i,
+ infobuf.assert_timestamp.tv_sec,
+ infobuf.assert_timestamp.tv_nsec,
+ infobuf.assert_sequence,
+ infobuf.clear_timestamp.tv_sec,
+ infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ int num, try_link = 0; /* by default use findsource */
+ char link[STRING_LEN] = "/dev/gps0"; /* just a default device */
+ pps_handle_t handle[4];
+ int avail_mode[4];
+ int i = 0, ret;
+
+ if (argc == 1) {
+ ret = find_source(try_link, link, &handle[0], &avail_mode[0]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+
+ num = 1;
+ } else {
+ for (i = 1; i < argc && i <= 4; i++) {
+ ret = sscanf(argv[i], "%d", &num);
+ if (ret < 1) {
+ try_link = ~0;
+ strncpy(link, argv[i], STRING_LEN);
+ }
+
+ ret =
+ find_source(try_link, link, &handle[i - 1],
+ &avail_mode[i - 1]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+ }
+
+ num = i - 1;
+ }
+
+ printf("ok, found %d source(s), now start fetching data...\n", num);
+
+ /* loop, printing the most recent timestamp every second or so */
+ while (1) {
+ for (i = 0; i < num; i++) {
+ ret = fetch_source(i, &handle[i], &avail_mode[i]);
+ if (ret < 0 && errno != ETIMEDOUT)
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ for (; i >= 0; i--)
+ time_pps_destroy(handle[i]);
+
+ return 0;
+}
diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
new file mode 100644
index 0000000..dee1782
--- /dev/null
+++ b/Documentation/pps/timepps.h
@@ -0,0 +1,234 @@
+/*
+ * timepps.h -- PPS API main header
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+#ifndef _SYS_TIMEPPS_H_
+#define _SYS_TIMEPPS_H_
+
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <errno.h>
+#include <linux/pps.h>
+
+/*
+ * New data structures
+ */
+
+struct ntp_fp {
+ unsigned int integral;
+ unsigned int fractional;
+};
+
+union pps_timeu {
+ struct timespec tspec;
+ struct ntp_fp ntpfp;
+ unsigned long longpad[3];
+};
+
+struct pps_info {
+ unsigned long assert_sequence; /* seq. num. of assert event */
+ unsigned long clear_sequence; /* seq. num. of clear event */
+ union pps_timeu assert_tu; /* time of assert event */
+ union pps_timeu clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_params {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ union pps_timeu assert_off_tu; /* offset compensation for assert */
+ union pps_timeu clear_off_tu; /* offset compensation for clear */
+};
+
+typedef int pps_handle_t; /* represents a PPS source */
+typedef unsigned long pps_seq_t; /* sequence number */
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
+typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */
+typedef struct pps_info pps_info_t;
+typedef struct pps_params pps_params_t;
+
+#define assert_timestamp assert_tu.tspec
+#define clear_timestamp clear_tu.tspec
+
+#define assert_timestamp_ntpfp assert_tu.ntpfp
+#define clear_timestamp_ntpfp clear_tu.ntpfp
+
+#define assert_offset assert_off_tu.tspec
+#define clear_offset clear_off_tu.tspec
+
+#define assert_offset_ntpfp assert_off_tu.ntpfp
+#define clear_offset_ntpfp clear_off_tu.ntpfp
+
+/*
+ * The PPS API
+ */
+
+#define PPS_HAVE_FINDSOURCE 1
+#define pps_min(a, b) (a) < (b) ? a : b
+int time_pps_findsource(int index, char *path, int pathlen, char *idstring,
+ int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ data.source = index;
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+ strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+/* Defined iff PPS_HAVE_FINDPATH is defined */
+void time_pps_readlink(char *link, int linklen, char *path, int pathlen)
+{
+ int i;
+
+ i = readlink(link, path, pathlen - 1);
+ if (i <= 0) {
+ /* "link" is not a valid symbolic so we directly use it */
+ strncpy(path, link, linklen <= pathlen ? linklen : pathlen);
+ return;
+ }
+
+ /* Return the file name where "link" points to */
+ path[i] = '\0';
+}
+
+#define PPS_HAVE_FINDPATH 1
+int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+int time_pps_create(int source, pps_handle_t *handle)
+{
+ if (!handle) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* In LinuxPPS there are no differences between a PPS source and
+ * a PPS handle so we return the same value.
+ */
+ *handle = source;
+
+ return 0;
+}
+
+int time_pps_destroy(pps_handle_t handle)
+{
+ /* Nothing to destroy here */
+
+ return 0;
+}
+
+int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
+{
+ int ret;
+ struct pps_kparams __ppsparams;
+
+ ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+
+ ppsparams->api_version = __ppsparams.api_version;
+ ppsparams->mode = __ppsparams.mode;
+ ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;
+ ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;
+ ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;
+ ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;
+
+ return ret;
+}
+
+int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
+{
+ struct pps_kparams __ppsparams;
+
+ __ppsparams.api_version = ppsparams->api_version;
+ __ppsparams.mode = ppsparams->mode;
+ __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;
+ __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;
+ __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;
+ __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;
+
+ return syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+}
+
+/* Get capabilities for handle */
+int time_pps_getcap(pps_handle_t handle, int *mode)
+{
+ return syscall(__NR_time_pps_getcap, handle, mode);
+}
+
+int time_pps_fetch(pps_handle_t handle, const int tsformat,
+ pps_info_t *ppsinfobuf, const struct timespec *timeout)
+{
+ struct pps_kinfo __ppsinfobuf;
+ struct pps_ktime __timeout;
+ int ret;
+
+ /* Sanity checks */
+ if (tsformat != PPS_TSFMT_TSPEC) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (timeout) {
+ __timeout.sec = timeout->tv_sec;
+ __timeout.nsec = timeout->tv_nsec;
+ }
+
+ ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf,
+ timeout ? &__timeout : NULL);
+
+ ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence;
+ ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence;
+ ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec;
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec;
+ ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec;
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec;
+ ppsinfobuf->current_mode = __ppsinfobuf.current_mode;
+
+ return ret;
+}
+
+int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
+ const int edge, const int tsformat)
+{
+ /* LinuxPPS doesn't implement kernel consumer feature */
+ errno = EOPNOTSUPP;
+ return -1;
+}
+
+#endif /* _SYS_TIMEPPS_H_ */
diff --git a/MAINTAINERS b/MAINTAINERS
index df40a4e..17e9a02 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2903,6 +2903,13 @@ P: Michal Ostrowski
M: mostrows@speakeasy.net
S: Maintained
+PPS SUPPORT
+P: Rodolfo Giometti
+M: giometti@enneenne.com
+W: http://wiki.enneenne.com/index.php/LinuxPPS_support
+L: linuxpps@ml.enneenne.com
+S: Maintained
+
PREEMPTIBLE KERNEL
P: Robert Love
M: rml@tech9.net
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index bf6adce..f1bf4ff 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -323,3 +323,8 @@ ENTRY(sys_call_table)
.long sys_signalfd
.long sys_timerfd
.long sys_eventfd
+ .long sys_time_pps_cmd
+ .long sys_time_pps_getparams /* 325 */
+ .long sys_time_pps_setparams
+ .long sys_time_pps_getcap
+ .long sys_time_pps_fetch
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 050323f..bb54cab 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
source "drivers/spi/Kconfig"
+source "drivers/pps/Kconfig"
+
source "drivers/w1/Kconfig"
source "drivers/hwmon/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index adad2f3..985d495 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/
obj-$(CONFIG_I2O) += message/
obj-$(CONFIG_RTC_LIB) += rtc/
obj-y += i2c/
+obj-$(CONFIG_PPS) += pps/
obj-$(CONFIG_W1) += w1/
obj-$(CONFIG_HWMON) += hwmon/
obj-$(CONFIG_PHONE) += telephony/
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 62051f8..403753f 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -746,6 +746,27 @@ static struct console lpcons = {
#endif /* console on line printer */
+/* Support for PPS signal on the line printer */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+
+static void lp_pps_echo(int source, int event, void *data)
+{
+ struct parport *port = data;
+ unsigned char status = parport_read_status(port);
+
+ /* echo event via SEL bit */
+ parport_write_control(port,
+ parport_read_control(port) | PARPORT_CONTROL_SELECT);
+
+ /* signal no event */
+ if ((status & PARPORT_STATUS_ACK) != 0)
+ parport_write_control(port,
+ parport_read_control(port) & ~PARPORT_CONTROL_SELECT);
+}
+
+#endif
+
/* --- initialisation code ------------------------------------- */
static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
@@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port)
}
#endif
+#ifdef CONFIG_PPS_CLIENT_LP
+ snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr);
+
+ /* No PPS support if lp port has no IRQ line */
+ if (port->irq != PARPORT_IRQ_NONE) {
+ strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN);
+
+ port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ port->pps_info.echo = lp_pps_echo;
+
+ port->pps_source = pps_register_source(&(port->pps_info),
+ PPS_CAPTUREASSERT | PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (port->pps_source < 0)
+ pps_err("cannot register PPS source \"%s\"",
+ port->pps_info.path);
+ else
+ pps_info("PPS source #%d \"%s\" added to the system",
+ port->pps_source, port->pps_info.path);
+ } else {
+ port->pps_source = -1;
+ pps_err("PPS support disabled due port \"%s\" is in polling mode",
+ port->pps_info.path);
+ }
+#endif
+
return 0;
}
@@ -860,6 +910,14 @@ static void lp_detach (struct parport *port)
console_registered = NULL;
}
#endif /* CONFIG_LP_CONSOLE */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ if (port->pps_source >= 0) {
+ pps_unregister_source(&(port->pps_info));
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, port->pps_info.path);
+ }
+#endif
}
static struct parport_driver lp_driver = {
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 0000000..a00b59a
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,31 @@
+#
+# PPS support configuration
+#
+
+menu "PPS support"
+
+config PPS
+ bool "PPS support"
+ depends on EXPERIMENTAL
+ ---help---
+ PPS (Pulse Per Second) is a special pulse provided by some GPS
+ antennae. Userland can use it to get an high time reference.
+
+ Some antennae's PPS signals are connected with the CD (Carrier
+ Detect) pin of the serial line they use to communicate with the
+ host. In this case use the SERIAL_LINE client support.
+
+ Some antennae's PPS signals are connected with some special host
+ inputs so you have to enable the corresponding client support.
+
+config PPS_DEBUG
+ bool "PPS debugging messages"
+ depends on PPS
+ help
+ Say Y here if you want the PPS support to produce a bunch of debug
+ messages to the system log. Select this if you are having a
+ problem with PPS support and want to see more of what is going on.
+
+source drivers/pps/clients/Kconfig
+
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 0000000..76101cd
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the PPS core.
+#
+
+pps_core-objs += pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS) += pps_core.o
+obj-y += clients/
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 0000000..58a1e55
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,30 @@
+#
+# PPS clients configuration
+#
+
+if PPS
+
+comment "PPS clients support"
+
+config PPS_CLIENT_KTIMER
+ tristate "Kernel timer client (Testing client, use for debug)"
+ help
+ If you say yes here you get support for a PPS debugging client
+ which uses a kernel timer to generate the PPS signal.
+
+ This driver can also be built as a module. If so, the module
+ will be called ktimer.ko.
+
+config PPS_CLIENT_UART
+ bool "UART serial support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the CD (Carrier Detect) pin of your serial port.
+
+config PPS_CLIENT_LP
+ bool "Parallel printer support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the interrupt pin of your parallel port.
+
+endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
new file mode 100644
index 0000000..10d1dfa
--- /dev/null
+++ b/drivers/pps/clients/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for PPS clients.
+#
+
+obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
+
diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c
new file mode 100644
index 0000000..efd6eba
--- /dev/null
+++ b/drivers/pps/clients/ktimer.c
@@ -0,0 +1,114 @@
+/*
+ * ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+
+#include <linux/pps.h>
+
+/*
+ * Global variables
+ */
+
+static int source;
+static struct timer_list ktimer;
+
+/*
+ * The kernel timer
+ */
+
+static void pps_ktimer_event(unsigned long ptr)
+{
+ pps_info("PPS event at %lu", jiffies);
+
+ pps_event(source, PPS_CAPTUREASSERT, NULL);
+
+ mod_timer(&ktimer, jiffies + HZ);
+}
+
+/*
+ * The echo function
+ */
+
+static void pps_ktimer_echo(int source, int event, void *data)
+{
+ pps_info("echo %s %s for source %d",
+ event & PPS_CAPTUREASSERT ? "assert" : "",
+ event & PPS_CAPTURECLEAR ? "clear" : "",
+ source);
+}
+
+/*
+ * The PPS info struct
+ */
+
+static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+ del_timer_sync(&ktimer);
+ pps_unregister_source(&pps_ktimer_info);
+
+ pps_info("ktimer PPS source unregistered");
+}
+
+static int __init pps_ktimer_init(void)
+{
+ int ret;
+
+ ret = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register ktimer source");
+ return ret;
+ }
+ source = ret;
+
+ setup_timer(&ktimer, pps_ktimer_event, 0);
+ mod_timer(&ktimer, jiffies + HZ);
+
+ pps_info("ktimer PPS source registered at %d", source);
+
+ return 0;
+}
+
+module_init(pps_ktimer_init);
+module_exit(pps_ktimer_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 0000000..3047462
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,242 @@
+/*
+ * kapi.c -- kernel API
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/pps.h>
+
+/*
+ * Local functions
+ */
+
+void dummy_echo(int source, int event, void *data)
+{
+ /* Nop */
+}
+
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+ ts->nsec += offset->nsec;
+ if (ts->nsec >= NSEC_PER_SEC) {
+ ts->nsec -= NSEC_PER_SEC;
+ ts->sec++;
+ } else if (ts->nsec < 0) {
+ ts->nsec += NSEC_PER_SEC;
+ ts->sec--;
+ }
+ ts->sec += offset->sec;
+}
+
+static void pps_tasklet(unsigned long data)
+{
+ int source = data;
+ struct pps_ktime ts;
+
+ struct timespec __ts;
+ int event;
+
+ /* If we are here then the source is allocated so no need to use
+ * pps_is_allocated().
+ */
+
+ /* Get the last event data saved by the IRQ handler */
+ __ts = pps_source[source].ts;
+ event = pps_source[source].event;
+
+ /* Translate the saved timestamp into PPS time data struct */
+ ts.sec = __ts.tv_sec;
+ ts.nsec = __ts.tv_nsec;
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
+ pps_err("unknow event (%x) for source %d", event, source);
+ return;
+ }
+
+ /* Check the event */
+ pps_source[source].current_mode = pps_source[source].params.mode;
+ if (event & PPS_CAPTUREASSERT) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETASSERT)
+ pps_add_offset(&ts,
+ &pps_source[source].params.assert_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].assert_tu = ts;
+ pps_source[source].assert_sequence++;
+ pps_dbg("capture assert seq #%u for source %d",
+ pps_source[source].assert_sequence, source);
+ }
+ if (event & PPS_CAPTURECLEAR) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETCLEAR)
+ pps_add_offset(&ts,
+ &pps_source[source].params.clear_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].clear_tu = ts;
+ pps_source[source].clear_sequence++;
+ pps_dbg("capture clear seq #%u for source %d",
+ pps_source[source].clear_sequence, source);
+ }
+
+ pps_source[source].go = ~0;
+ wake_up_interruptible(&pps_source[source].queue);
+}
+
+/*
+ * Exported functions
+ */
+
+int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+{
+ int i = -1, err = 0, ret;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ if (try_id >= 0) {
+ if (pps_is_allocated(try_id)) {
+ pps_err("source id %d busy", try_id);
+ err = -EBUSY;
+ goto pps_register_source_exit;
+ }
+ i = try_id;
+ } else {
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (!pps_is_allocated(i))
+ break;
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("no free source ids");
+ err = -ENOMEM;
+ goto pps_register_source_exit;
+ }
+ }
+ tasklet_disable(&pps_source[i].tasklet);
+ tasklet_kill(&pps_source[i].tasklet);
+
+ /* Sanity checks */
+ if ((info->mode & default_params) != default_params) {
+ pps_err("unsupported default parameters");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+ info->echo == NULL) {
+ pps_err("echo function is not defined");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ pps_err("unspecified time format");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+
+ /* Allocate the PPS source. */
+ memset(&pps_source[i], 0, sizeof(struct pps_s));
+ pps_source[i].params.api_version = PPS_API_VERS;
+ pps_source[i].params.mode = default_params;
+ init_waitqueue_head(&pps_source[i].queue);
+
+ /* Allocate the PPS source */
+ pps_source[i].info = info;
+ pps_source[i].echo = info->echo;
+
+ /* Register the new tasklet's body and (re)enable it */
+ tasklet_init(&pps_source[i].tasklet, pps_tasklet, i);
+
+pps_register_source_exit :
+ mutex_unlock(&pps_mutex);
+
+ if (err < 0)
+ return err;
+
+ ret = pps_sysfs_create_source_entry(info, i);
+ if (ret < 0)
+ pps_err("unable to create sysfs entry for source %d", i);
+
+ return i;
+}
+EXPORT_SYMBOL(pps_register_source);
+
+void pps_unregister_source(struct pps_source_info_s *info)
+{
+ int i;
+
+ pps_sysfs_remove_source_entry(info);
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) && pps_source[i].info == info)
+ break;
+
+ if (i >= PPS_MAX_SOURCES) {
+ pps_err("warning! Try to unregister an unknow PPS source");
+ goto pps_unregister_source_exit;
+ }
+
+ /* Stop any running tasklets */
+ tasklet_kill(&pps_source[i].tasklet);
+
+ /* Deallocate the PPS source */
+ pps_source[i].info = NULL;
+ pps_source[i].echo = dummy_echo;
+
+pps_unregister_source_exit :
+ mutex_unlock(&pps_mutex);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+
+void pps_event(int source, int event, void *data)
+{
+ struct timespec ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&ts);
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
+ pps_err("unknow event (%x) for source %d", event, source);
+ return;
+ }
+
+ /* Must call the echo function?
+ * Note that we don't use the function inside the "info" structure
+ * since "info" pointer could be NULL!
+ */
+ rmb();
+ if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+ pps_source[source].echo(source, event, data);
+
+ /* Save the event data for later and safer time... */
+ pps_source[source].event = event;
+ pps_source[source].ts = ts;
+
+ /* ... then schedule the tasklet */
+ tasklet_schedule(&pps_source[source].tasklet);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 0000000..49bcc93
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,399 @@
+/*
+ * pps.c -- Main PPS support file
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/linkage.h>
+#include <linux/sched.h>
+#include <linux/pps.h>
+#include <linux/uaccess.h>
+
+/*
+ * Global variables
+ */
+
+struct pps_s pps_source[PPS_MAX_SOURCES];
+DEFINE_MUTEX(pps_mutex);
+
+/*
+ * Misc functions
+ */
+
+static void dummy_tasklet(unsigned long data)
+{
+ /* Nop */
+}
+
+static inline int pps_check_source(int source)
+{
+ return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0;
+}
+
+static int pps_find_source(int source)
+{
+ int i;
+
+ if (source >= 0) {
+ if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source))
+ return -EINVAL;
+ else
+ return source;
+ }
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+static int pps_find_path(char *path)
+{
+ int i;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) &&
+ (strncmp(pps_source[i].info->path, path,
+ PPS_MAX_NAME_LEN) == 0 ||
+ strncmp(pps_source[i].info->name, path,
+ PPS_MAX_NAME_LEN) == 0))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+/*
+ * PPS System Calls
+ */
+
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg)
+{
+ struct pps_source_data_s data;
+ int ret = 0;
+
+ pps_dbg("%s: cmd %d", __FUNCTION__, cmd);
+
+ /* Sanity checks */
+ if (_IOC_TYPE(cmd) != 'P')
+ return -EOPNOTSUPP;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ switch (cmd) {
+ case PPS_CMD_FIND_SRC :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source);
+
+ data.source = pps_find_source(data.source);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ case PPS_CMD_FIND_PATH :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path);
+
+ data.source = pps_find_path(data.path);
+ if (data.source < 0) {
+ pps_dbg("no PPS devices found");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ default :
+ pps_err("invalid sys_time_pps_cmd %d", cmd);
+ ret = -EOPNOTSUPP;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ /* Found! So copy the info */
+ strncpy(data.name, pps_source[data.source].info->name,
+ PPS_MAX_NAME_LEN);
+ strncpy(data.path, pps_source[data.source].info->path,
+ PPS_MAX_NAME_LEN);
+
+ ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_cmd_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params)
+{
+ int ret = 0;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getparams_exit;
+ }
+
+ /* Return current parameters */
+ ret = copy_to_user(params, &pps_source[source].params,
+ sizeof(struct pps_kparams));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_getparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Check the capabilities */
+ if (!capable(CAP_SYS_TIME))
+ return -EPERM;
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+ if ((params->mode & ~pps_source[source].info->mode) != 0) {
+ pps_dbg("unsupported capabilities");
+ return -EINVAL;
+ }
+ if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+ pps_dbg("capture mode unspecified");
+ return -EINVAL;
+ }
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Save the new parameters */
+ ret = copy_from_user(&pps_source[source].params, params,
+ sizeof(struct pps_kparams));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Restore the read only parameters */
+ if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ /* section 3.3 of RFC 2783 interpreted */
+ pps_dbg("time format unspecified");
+ pps_source[source].params.mode |= PPS_TSFMT_TSPEC;
+ }
+ if (pps_source[source].info->mode & PPS_CANWAIT)
+ pps_source[source].params.mode |= PPS_CANWAIT;
+ pps_source[source].params.api_version = PPS_API_VERS;
+
+sys_time_pps_setparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode)
+{
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!mode)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getcap_exit;
+ }
+
+ ret = put_user(pps_source[source].info->mode, mode);
+
+sys_time_pps_getcap_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout)
+{
+ unsigned long ticks;
+ struct pps_kinfo pi;
+ struct pps_ktime to;
+ int ret;
+
+ pps_dbg("%s: source %d", __FUNCTION__, source);
+
+ if (!info)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ pps_source[source].go = 0;
+
+ /* Manage the timeout */
+ if (timeout) {
+ ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime));
+ if (ret) {
+ goto sys_time_pps_fetch_exit;
+ ret = -EFAULT;
+ }
+ pps_dbg("timeout %lld.%09d", to.sec, to.nsec);
+ ticks = to.sec * HZ;
+ ticks += to.nsec / (NSEC_PER_SEC / HZ);
+
+ if (ticks != 0) {
+ ret = wait_event_interruptible_timeout(
+ pps_source[source].queue,
+ pps_source[source].go, ticks);
+ if (ret == 0) {
+ pps_dbg("timeout expired");
+ ret = -ETIMEDOUT;
+ goto sys_time_pps_fetch_exit;
+ }
+ }
+ } else
+ ret = wait_event_interruptible(pps_source[source].queue,
+ pps_source[source].go);
+
+ /* Check for pending signals */
+ if (ret == -ERESTARTSYS) {
+ pps_dbg("pending signal caught");
+ ret = -EINTR;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ /* Return the fetched timestamp */
+ pi.assert_sequence = pps_source[source].assert_sequence;
+ pi.clear_sequence = pps_source[source].clear_sequence;
+ pi.assert_tu = pps_source[source].assert_tu;
+ pi.clear_tu = pps_source[source].clear_tu;
+ pi.current_mode = pps_source[source].current_mode;
+ ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_fetch_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_exit(void)
+{
+ pps_sysfs_unregister();
+
+ pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS);
+}
+
+static int __init pps_init(void)
+{
+ int i, ret;
+
+ /* Init pps_source info */
+ for (i = 0; i < PPS_MAX_SOURCES; i++) {
+ memset(&pps_source[i], 0, sizeof(struct pps_s));
+ tasklet_init(&pps_source[i].tasklet, dummy_tasklet, i);
+ init_waitqueue_head(&pps_source[i].queue);
+ }
+
+ /* Register to sysfs */
+ ret = pps_sysfs_register();
+ if (ret < 0) {
+ pps_err("unable to register sysfs");
+ return ret;
+ }
+
+ pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS);
+ pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+ "<giometti@linux.it>", PPS_VERSION);
+
+ return 0;
+}
+
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
new file mode 100644
index 0000000..e52dd8e
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,217 @@
+/*
+ * sysfs.c -- sysfs support
+ *
+ *
+ * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/device.h>
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <linux/pps.h>
+
+/*
+ * Private functions
+ */
+
+static ssize_t pps_show_assert(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->assert_tu.sec, dev->assert_tu.nsec,
+ dev->assert_sequence);
+}
+
+static ssize_t pps_show_clear(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->clear_tu.sec, dev->clear_tu.nsec,
+ dev->clear_sequence);
+}
+
+static ssize_t pps_show_mode(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%4x\n", info->mode);
+}
+
+static ssize_t pps_show_echo(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%d\n", !!info->echo);
+}
+
+static ssize_t pps_show_name(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->name);
+}
+
+static ssize_t pps_show_path(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->path);
+}
+
+/*
+ * Files definitions
+ */
+
+#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \
+{ \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = _mode, \
+ .owner = THIS_MODULE, \
+ }, \
+ .show = _show, \
+ .store = _store, \
+}
+
+static struct class_device_attribute pps_class_device_attributes[] = {
+ DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL),
+ DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL),
+ DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL),
+ DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL),
+ DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL),
+ DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL),
+};
+
+/*
+ * Class definitions
+ */
+
+static void pps_class_release(struct class_device *cdev)
+{
+ /* Nop??? */
+}
+
+static struct class pps_class = {
+ .name = "pps",
+ .release = pps_class_release,
+};
+
+/*
+ * Public functions
+ */
+
+void pps_sysfs_remove_source_entry(struct pps_source_info_s *info)
+{
+ int i;
+
+ /* Sanity checks */
+ if (info == NULL)
+ return;
+
+ /* Delete info files */
+ if (info->mode&PPS_CAPTUREASSERT)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+
+ if (info->mode&PPS_CAPTURECLEAR)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ /* Deregister the pps class */
+ class_device_unregister(&info->class_dev);
+}
+
+int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id)
+{
+ char buf[32];
+ int i, ret;
+
+ /* Sanity checks */
+ if (info == NULL || id >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ /* Create dir class device name */
+ sprintf(buf, "%.02d", id);
+
+ /* Setup the class struct */
+ memset(&info->class_dev, 0, sizeof(struct class_device));
+ info->class_dev.class = &pps_class;
+ strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN);
+ class_set_devdata(&info->class_dev, &pps_source[id]);
+
+ /* Register the new class */
+ ret = class_device_register(&info->class_dev);
+ if (unlikely(ret))
+ goto error_class_device_register;
+
+ /* Create info files */
+
+ /* Create file "assert" and "clear" according to source capability */
+ if (info->mode & PPS_CAPTUREASSERT) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+ i = 0;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+ if (info->mode & PPS_CAPTURECLEAR) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+ i = 1;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ return 0;
+
+error_class_device_create_file:
+ while (--i >= 0)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ class_device_unregister(&info->class_dev);
+ /* Here the release() method was already called */
+
+error_class_device_register:
+
+ return ret;
+}
+
+void pps_sysfs_unregister(void)
+{
+ class_unregister(&pps_class);
+}
+
+int pps_sysfs_register(void)
+{
+ return class_register(&pps_class);
+}
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c84dab0..0c9a307 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
up->ier |= UART_IER_MSI;
if (up->capabilities & UART_CAP_UUE)
up->ier |= UART_IER_UUE | UART_IER_RTOIE;
+ if (up->port.flags & UPF_HARDPPS_CD)
+ up->ier |= UART_IER_MSI; /* enable interrupts */
serial_out(up, UART_IER, up->ier);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 326020f..bd12165 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -33,6 +33,7 @@
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
#include <linux/delay.h>
#include <linux/mutex.h>
+#include <linux/pps.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
@@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state,
return 0;
}
+#ifdef CONFIG_PPS_CLIENT_UART
+
+static int
+uart_register_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ struct tty_driver *drv = port->info->tty->driver;
+ int ret;
+
+ snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d",
+ drv->driver_name, port->line);
+ snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d",
+ drv->name, port->line);
+
+ state->pps_info.mode = PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR,
+ -1 /* PPS ID is up to the system */);
+ if (ret < 0) {
+ pps_err("cannot register PPS source \"%s\"",
+ state->pps_info.path);
+ return ret;
+ }
+ port->pps_source = ret;
+ pps_info("PPS source #%d \"%s\" added to the system ",
+ port->pps_source, state->pps_info.path);
+
+ return 0;
+}
+
+static void
+uart_unregister_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ pps_unregister_source(&state->pps_info);
+ pps_dbg("PPS source #%d \"%s\" removed from the system",
+ port->pps_source, state->pps_info.path);
+}
+
+#else
+
+#define uart_register_pps_port(state, port) do { } while (0)
+#define uart_unregister_pps_port(state, port) do { } while (0)
+
+#endif /* CONFIG_PPS_CLIENT_UART */
+
static int uart_set_info(struct uart_state *state,
struct serial_struct __user *newinfo)
{
@@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state,
(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
check_and_exit:
+ /* PPS support enabled/disabled? */
+ if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) {
+ if (new_flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+ else
+ uart_unregister_pps_port(state, port);
+ }
+
retval = 0;
if (port->type == PORT_UNKNOWN)
goto exit;
if (state->info->flags & UIF_INITIALIZED) {
- if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
+ if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) ||
old_custom_divisor != port->custom_divisor) {
/*
* If they're setting up a custom divisor or speed,
@@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
port->ops->config_port(port, flags);
}
+ /*
+ * Add the PPS support for the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+
if (port->type != PORT_UNKNOWN) {
unsigned long flags;
@@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
mutex_unlock(&state->mutex);
/*
+ * Remove PPS support from the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_unregister_pps_port(state, port);
+
+ /*
* Remove the devices from the tty layer
*/
tty_unregister_device(drv->tty_driver, port->line);
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index e84ace1..36746dc 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -329,10 +329,15 @@
#define __NR_signalfd 321
#define __NR_timerfd 322
#define __NR_eventfd 323
+#define __NR_time_pps_cmd 324
+#define __NR_time_pps_getparams 325
+#define __NR_time_pps_setparams 326
+#define __NR_time_pps_getcap 327
+#define __NR_time_pps_fetch 328
#ifdef __KERNEL__
-#define NR_syscalls 324
+#define NR_syscalls 329
#define __ARCH_WANT_IPC_PARSE_VERSION
#define __ARCH_WANT_OLD_READDIR
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index f317c27..a10d20a 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -293,6 +293,7 @@ unifdef-y += pmu.h
unifdef-y += poll.h
unifdef-y += ppp_defs.h
unifdef-y += ppp-comp.h
+unifdef-y += pps.h
unifdef-y += ptrace.h
unifdef-y += qnx4_fs.h
unifdef-y += quota.h
diff --git a/include/linux/parport.h b/include/linux/parport.h
index 9cdd694..f53d9f4 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -100,6 +100,7 @@ typedef enum {
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
+#include <linux/pps.h>
#include <asm/system.h>
#include <asm/ptrace.h>
#include <asm/semaphore.h>
@@ -327,6 +328,11 @@ struct parport {
struct list_head full_list;
struct parport *slaves[3];
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ struct pps_source_info_s pps_info;
+ int pps_source; /* PPS source ID */
+#endif
};
#define DEFAULT_SPIN_TIME 500 /* us */
@@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode);
/* Lowlevel drivers _can_ call this support function to handle irqs. */
static __inline__ void parport_generic_irq(int irq, struct parport *port)
{
+#ifdef CONFIG_PPS_CLIENT_LP
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("parport_pc: PPS assert event at %lu on source #%d",
+ jiffies, port->pps_source);
+#endif
+
parport_ieee1284_interrupt (irq, port);
read_lock(&port->cad_lock);
if (port->cad && port->cad->irq_func)
diff --git a/include/linux/pps.h b/include/linux/pps.h
new file mode 100644
index 0000000..901a3b5
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,213 @@
+/*
+ * pps.h -- PPS API kernel header.
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+
+#ifndef _PPS_H_
+#define _PPS_H_
+
+/* Implementation note: the logical states ``assert'' and ``clear''
+ * are implemented in terms of the chip register, i.e. ``assert''
+ * means the bit is set. */
+
+/*
+ * 3.2 New data structures
+ */
+
+#ifndef __KERNEL__
+#include <linux/types.h>
+#include <sys/time.h>
+#else
+#include <linux/time.h>
+#endif
+
+#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */
+#define PPS_API_VERS PPS_API_VERS_2
+#define LINUXPSS_API 1 /* mark LinuxPPS API */
+
+#define PPS_MAX_NAME_LEN 32
+
+struct pps_ktime {
+ __u64 sec;
+ __u32 nsec;
+};
+
+struct pps_kinfo {
+ __u32 assert_sequence; /* seq. num. of assert event */
+ __u32 clear_sequence; /* seq. num. of clear event */
+ struct pps_ktime assert_tu; /* time of assert event */
+ struct pps_ktime clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_kparams {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ struct pps_ktime assert_off_tu; /* offset compensation for assert */
+ struct pps_ktime clear_off_tu; /* offset compensation for clear */
+};
+
+/*
+ * 3.3 Mode bit definitions
+ */
+
+/* Device/implementation parameters */
+#define PPS_CAPTUREASSERT 0x01 /* capture assert events */
+#define PPS_CAPTURECLEAR 0x02 /* capture clear events */
+#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
+
+#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
+#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
+
+#define PPS_CANWAIT 0x100 /* can we wait for an event? */
+#define PPS_CANPOLL 0x200 /* bit reserved for future use */
+
+/* Kernel actions */
+#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
+#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
+
+/* Timestamp formats */
+#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
+#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
+
+/*
+ * 3.4.4 New functions: disciplining the kernel timebase
+ */
+
+/* Kernel consumers */
+#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */
+#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to
+ use a phase-locked loop */
+#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to
+ use a frequency-locked loop */
+/*
+ * Here begins the implementation-specific part!
+ */
+
+#include <linux/ioctl.h>
+
+struct pps_source_data_s {
+ int source;
+ char name[PPS_MAX_NAME_LEN];
+ char path[PPS_MAX_NAME_LEN];
+};
+
+#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *)
+#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *)
+
+#ifdef __KERNEL__
+
+#include <linux/interrupt.h>
+#include <linux/device.h>
+
+/*
+ * Misc macros
+ */
+
+#define PPS_VERSION "4.0.0-rc4"
+
+#ifdef CONFIG_PPS_DEBUG
+#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#else
+#define pps_dbg(format, arg...) do {} while (0)
+#endif
+
+#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
+ KBUILD_MODNAME , ## arg)
+
+/*
+ * Global defines
+ */
+
+#define PPS_MAX_SOURCES 16
+
+/* The specific PPS source info */
+struct pps_source_info_s {
+ char name[PPS_MAX_NAME_LEN]; /* simbolic name */
+ char path[PPS_MAX_NAME_LEN]; /* path of connected device */
+ int mode; /* PPS's allowed mode */
+
+ void (*echo)(int source, int event, void *data); /* PPS echo function */
+
+ /* sysfs section */
+ struct class_device class_dev;
+};
+
+/* The main struct */
+struct pps_s {
+ struct pps_source_info_s *info; /* PSS source info */
+
+ struct pps_kparams params; /* PPS's current params */
+
+ __u32 assert_sequence; /* PPS' assert event seq # */
+ __u32 clear_sequence; /* PPS' clear event seq # */
+ struct pps_ktime assert_tu;
+ struct pps_ktime clear_tu;
+ int current_mode; /* PPS mode at event time */
+
+ void (*echo)(int source, int event, void *data); /* PPS echo function */
+
+ int event; /* the last PPS event */
+ struct timespec ts; /* the last PPS timestamp */
+ struct tasklet_struct tasklet;
+
+ int go; /* PPS event is arrived? */
+ wait_queue_head_t queue; /* PPS event queue */
+};
+
+/*
+ * Global variables
+ */
+
+extern struct pps_s pps_source[PPS_MAX_SOURCES];
+extern struct mutex pps_mutex;
+
+/*
+ * Global functions
+ */
+
+static inline int pps_is_allocated(int source)
+{
+ return pps_source[source].info != NULL;
+}
+
+#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev)
+
+/*
+ * Exported functions
+ */
+
+extern int pps_register_source(struct pps_source_info_s *info,
+ int default_params, int try_id);
+extern void pps_unregister_source(struct pps_source_info_s *info);
+extern void pps_event(int source, int event, void *data);
+
+extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info,
+ int id);
+extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info);
+extern int pps_sysfs_register(void);
+extern void pps_sysfs_unregister(void);
+
+#endif /* __KERNEL__ */
+
+#endif /* _PPS_H_ */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 7f2c99d..654ad19 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -153,6 +153,7 @@
#include <linux/tty.h>
#include <linux/mutex.h>
#include <linux/sysrq.h>
+#include <linux/pps.h>
struct uart_port;
struct uart_info;
@@ -232,6 +233,9 @@ struct uart_port {
unsigned char regshift; /* reg offset shift */
unsigned char iotype; /* io access style */
unsigned char unused1;
+#ifdef CONFIG_PPS_CLIENT_UART
+ int pps_source; /* PPS source ID */
+#endif
#define UPIO_PORT (0)
#define UPIO_HUB6 (1)
@@ -276,7 +280,8 @@ struct uart_port {
#define UPF_IOREMAP ((__force upf_t) (1 << 31))
#define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))
-#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
+#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\
+ |UPF_HARDPPS_CD))
unsigned int mctrl; /* current modem ctrl settings */
unsigned int timeout; /* character-based timeout */
@@ -308,6 +313,10 @@ struct uart_state {
struct uart_info *info;
struct uart_port *port;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct pps_source_info_s pps_info;
+#endif
+
struct mutex mutex;
};
@@ -472,13 +481,26 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
- port->icount.dcd++;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct tty_driver *drv = port->info->tty->driver;
-#ifdef CONFIG_HARD_PPS
- if ((port->flags & UPF_HARDPPS_CD) && status)
- hardpps();
+ if (port->flags & UPF_HARDPPS_CD) {
+ if (status) {
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ pps_dbg("%s%d: PPS assert event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ } else {
+ pps_event(port->pps_source, PPS_CAPTURECLEAR, port);
+ pps_dbg("%s%d: PPS clear event at %lu on source #%d",
+ drv->driver_name, port->line,
+ jiffies, port->pps_source);
+ }
+ }
#endif
+ port->icount.dcd++;
+
if (info->flags & UIF_CHECK_CD) {
if (status)
wake_up_interruptible(&info->open_wait);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 83d0ec1..bfc8899 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -65,6 +65,7 @@ struct getcpu_cache;
#include <asm/signal.h>
#include <linux/quota.h>
#include <linux/key.h>
+#include <linux/pps.h>
asmlinkage long sys_time(time_t __user *tloc);
asmlinkage long sys_stime(time_t __user *tptr);
@@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags,
const struct itimerspec __user *utmr);
asmlinkage long sys_eventfd(unsigned int count);
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg);
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode);
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout);
+
int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 7e11e2c..e0fccc2 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -148,3 +148,10 @@ cond_syscall(sys_timerfd);
cond_syscall(compat_sys_signalfd);
cond_syscall(compat_sys_timerfd);
cond_syscall(sys_eventfd);
+
+/* PPS dependent */
+cond_syscall(sys_time_pps_find);
+cond_syscall(sys_time_pps_getparams);
+cond_syscall(sys_time_pps_setparams);
+cond_syscall(sys_time_pps_getcap);
+cond_syscall(sys_time_pps_fetch);
^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:45 ` David Woodhouse
@ 2007-07-24 16:09 ` Rodolfo Giometti
0 siblings, 0 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-24 16:09 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
On Tue, Jul 24, 2007 at 03:45:19PM +0100, David Woodhouse wrote:
> On Tue, 2007-07-24 at 16:31 +0200, Rodolfo Giometti wrote:
> > drivers/built-in.o: In function `sys_time_pps_fetch':
> > (.text+0x5f05e): undefined reference to `__udivdi3'
>
> Hm, not sure. Maybe put it back to uint32_t and then add another
> uint32_t of explicit padding, or maybe just cast it to uint32_t when you
> divide:
>
> ticks += (uint32_t)to.nsec / (NSEC_PER_SEC/HZ);
Ok, padding data added. :)
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version
2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti
2007-07-24 14:45 ` David Woodhouse
@ 2007-07-26 19:52 ` Roman Zippel
1 sibling, 0 replies; 43+ messages in thread
From: Roman Zippel @ 2007-07-26 19:52 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton
Hi,
On Tuesday 24 July 2007, Rodolfo Giometti wrote:
> By doing:
>
> struct pps_ktime {
> __u64 sec;
> - __u32 nsec;
> + __u64 nsec;
> };
Just using __u32 for both works as well...
bye, Roman
^ permalink raw reply [flat|nested] 43+ messages in thread
* LinuxPPS & spinlocks
2007-07-24 14:52 ` David Woodhouse
2007-07-24 16:01 ` Rodolfo Giometti
@ 2007-07-27 18:44 ` Rodolfo Giometti
2007-07-27 19:08 ` Chris Friesen
1 sibling, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-27 18:44 UTC (permalink / raw)
To: David Woodhouse; +Cc: linux-kernel, Andrew Morton
[-- Attachment #1: Type: text/plain, Size: 801 bytes --]
By looking at spinlocks and thinking better to the lock problems for
pps_events() I found this (possible) solution...
The pps_event() is now protected by a spinlock against
pps_register_source() and pps_unregister_source(), but since I cannot
disable IRQs I used the spin_trylock() into the pps_events() so even
if the process context holds the lock and an PPS event arrives (IRQ)
the system doesn't hang. Note that we cannot lose an event without
problems.
It could be more acceptable? I removed the "volatile" attribute! :)
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
[-- Attachment #2: proposed_patch --]
[-- Type: text/plain, Size: 67887 bytes --]
diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
new file mode 100644
index 0000000..a2660a2
--- /dev/null
+++ b/Documentation/pps/Makefile
@@ -0,0 +1,27 @@
+TARGETS = ppstest ppsctl
+
+CFLAGS += -Wall -O2 -D_GNU_SOURCE
+CFLAGS += -I .
+CFLAGS += -ggdb
+
+# -- Actions section ----------------------------------------------------------
+
+.PHONY : all depend dep
+
+all : .depend $(TARGETS)
+
+.depend depend dep :
+ $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
+
+
+# -- Clean section ------------------------------------------------------------
+
+.PHONY : clean
+
+clean :
+ rm -f *.o *~ core .depend
+ rm -f ${TARGETS}
diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
new file mode 100644
index 0000000..511fa36
--- /dev/null
+++ b/Documentation/pps/pps.txt
@@ -0,0 +1,211 @@
+
+ PPS - Pulse Per Second
+ ----------------------
+
+(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com>
+
+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.
+
+
+
+Overview
+--------
+
+LinuxPPS provides a programming interface (API) to define into the
+system several PPS sources.
+
+PPS means "pulse per second" and a PPS source is just a device which
+provides a high precision signal each second so that an application
+can use it to adjust system clock time.
+
+A PPS source can be connected to a serial port (usually to the Data
+Carrier Detect pin) or to a parallel port (ACK-pin) or to a special
+CPU's GPIOs (this is the common case in embedded systems) but in each
+case when a new pulse comes the system must apply to it a timestamp
+and record it for the userland.
+
+Common use is the combination of the NTPD as userland program with a
+GPS receiver as PPS source to obtain a wallclock-time with
+sub-millisecond synchronisation to UTC.
+
+
+RFC considerations
+------------------
+
+While implementing a PPS API as RFC 2783 defines and using an embedded
+CPU GPIO-Pin as physical link to the signal, I encountered a deeper
+problem:
+
+ At startup it needs a file descriptor as argument for the function
+ time_pps_create().
+
+This implies that the source has a /dev/... entry. This assumption is
+ok for the serial and parallel port, where you can do something
+useful besides(!) the gathering of timestamps as it is the central
+task for a PPS-API. But this assumption does not work for a single
+purpose GPIO line. In this case even basic file-related functionality
+(like read() and write()) makes no sense at all and should not be a
+precondition for the use of a PPS-API.
+
+The problem can be simply solved if you change the original RFC 2783:
+
+ pps_handle_t type is an opaque __scalar type__ used to represent a
+ PPS source within the API
+
+into a modified:
+
+ pps_handle_t type is an opaque __variable__ used to represent a PPS
+ source within the API and programs should not access it directly to
+ it due to its opacity.
+
+This change seems to be neglibile because even the original RFC 2783
+does not encourage programs to check (read: use) the pps_handle_t
+variable before calling the time_pps_*() functions, since each
+function should do this job internally.
+
+If I intentionally separate the concept of "file descriptor" from the
+concept of the "PPS source" I'm obliged to provide a solution to find
+and register a PPS-source without using a file descriptor: it's done
+by the functions time_pps_findsource() and time_pps_findpath() now.
+
+According to this current NTPD drivers' code should be modified as
+follows:
+
++#ifdef PPS_HAVE_FINDPATH
++ /* Get the PPS source's real name */
++ fd = readlink(link, path, STRING_LEN-1);
++ if (fd <= 0)
++ strncpy(path, link, STRING_LEN);
++ else
++ path[fd] = '\0';
++
++ /* Try to find the source */
++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
++ if (fd < 0) {
++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" "
++ "in the system", path);
++ return 1;
++ }
++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"",
++ fd, path, id);
++#endif /* PPS_HAVE_FINDPATH */
++
++
+ if (time_pps_create(fd, &pps_handle) < 0) {
+- pps_handle = 0;
+ msyslog(LOG_ERR, "refclock: time_pps_create failed: %m");
+ }
+
+
+Coding example
+--------------
+
+To register a PPS source into the kernel you should define a struct
+pps_source_info_s as follow:
+
+ static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+ };
+
+and then calling the function pps_register_source() in your
+intialization routine as follow:
+
+ source = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+
+The pps_register_source() prototype is:
+
+ int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+
+where "info" is a pointer to a structure that describes a particular
+PPS source, "default_params" tells the system what the initial default
+parameters for the device should be (is obvious that these parameters
+must be a subset of ones defined into the struct
+pps_source_info_s which describe the capabilities of the driver)
+and "try_id" can be used to force a particular ID for your device into
+the system (just use -1 if you wish the system chooses one for you).
+
+Once you have registered a new PPS source into the system you can
+signal an assert event (for example in the interrupt handler routine)
+just using:
+
+ pps_event(source, PPS_CAPTUREASSERT, ptr);
+
+The same function may also run the defined echo function
+(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user
+asked for that... etc..
+
+Please see the file drivers/pps/clients/ktimer.c for an example code.
+
+
+SYSFS support
+-------------
+
+The SYSFS support is enabled by default if the SYSFS filesystem is
+enabled in the kernel and it provides a new class:
+
+ $ ls /sys/class/pps/
+ 00/ 01/ 02/
+
+Every directory is the ID of a PPS sources defined into the system and
+inside you find several files:
+
+ $ ls /sys/class/pps/00/
+ assert clear echo mode name path subsystem@ uevent
+
+Inside each "assert" and "clear" file you can find the timestamp and a
+sequence number:
+
+ $ cat /sys/class/pps/00/assert
+ 1170026870.983207967#8
+
+Where before the "#" is the timestamp in seconds and after it is the
+sequence number. Other files are:
+
+* echo: reports if the PPS source has an echo function or not;
+
+* mode: reports available PPS functioning modes;
+
+* name: reports the PPS source's name;
+
+* path: reports the PPS source's device path, that is the device the
+ PPS source is connected to (if it exists).
+
+
+Testing the PPS support
+-----------------------
+
+In order to test the PPS support even without specific hardware you can use
+the ktimer driver (see the client subsection in the PPS configuration menu)
+and the userland tools provided into Documentaion/pps/ directory.
+
+Once you have enabled the compilation of ktimer just modprobe it (if
+not statically compiled):
+
+ # modprobe ktimer
+
+and the run ppstest as follow:
+
+ $ ./ppstest
+ found PPS source #0 "ktimer" on ""
+ ok, found 1 source(s), now start fetching data...
+ source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0
+ source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0
+
+Please, note that to compile userland programs you need the file timepps.h
+(see Documentation/pps/).
diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c
new file mode 100644
index 0000000..17afcbd
--- /dev/null
+++ b/Documentation/pps/ppsctl.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/serial.h>
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);
+
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd, ret;
+ struct serial_struct ss;
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0) {
+ perror("open");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCGSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCGSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ if (argc < 3) { /* just read PPS status */
+ printf("PPS is %sabled\n",
+ ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");
+ exit(EXIT_SUCCESS);
+ }
+
+ if (argv[2][0] == 'e' || argv[2][0] == '1')
+ ss.flags |= ASYNC_HARDPPS_CD;
+ else if (argv[2][0] == 'd' || argv[2][0] == '0')
+ ss.flags &= ~ASYNC_HARDPPS_CD;
+ else {
+ fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCSSERIAL, &ss);
+ if (ret < 0) {
+ perror("ioctl(TIOCSSERIAL)");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
new file mode 100644
index 0000000..bfd1064
--- /dev/null
+++ b/Documentation/pps/ppstest.c
@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <timepps.h>
+
+#define STRING_LEN PPS_MAX_NAME_LEN
+
+int find_source(int try_link, char *link, pps_handle_t *handle,
+ int *avail_mode)
+{
+ int num = -1;
+ char id[STRING_LEN] = "", /* no ID string by default */
+ path[STRING_LEN];
+ pps_params_t params;
+ int ret;
+
+ if (try_link) {
+ printf("trying PPS source \"%s\"\n", link);
+#ifdef PPS_HAVE_FINDPATH
+ /* Get the PPS source's real name */
+ time_pps_readlink(link, STRING_LEN, path, STRING_LEN);
+
+ /* Try to find the source by using the supplied "path" name */
+ ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN);
+ if (ret < 0)
+ goto exit;
+ num = ret;
+#else
+#warning "cannot use time_pps_findpath()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDPATH */
+ }
+#ifdef PPS_HAVE_FINDSOURCE
+ /* Try to find the source (by using "index = -1" we ask just
+ * for a generic source) */
+ ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN);
+#else
+#warning "cannot use time_pps_findsource()"
+ ret = -1;
+#endif /* PPS_HAVE_FINDSOURCE */
+ if (ret < 0) {
+exit:
+ fprintf(stderr, "no available PPS source in the system\n");
+ return -1;
+ }
+ num = ret;
+ printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path);
+
+ /* If "path" is not NULL we should *at least* open the pointed
+ * device in order to enable the interrupts generation.
+ * Note that this can be NOT enough anyway, infact you may need sending
+ * additional commands to your GPS antenna before it starts sending
+ * the PPS signal. */
+ if (strlen(path)) {
+ ret = open(path, O_RDWR);
+ if (ret < 0) {
+ fprintf(stderr, "cannot open \"%s\" (%m)\n", path);
+ return -1;
+ }
+ }
+
+ /* Open the PPS source */
+ ret = time_pps_create(num, handle);
+ if (ret < 0) {
+ fprintf(stderr, "cannot create a PPS source (%m)\n");
+ return -1;
+ }
+
+ /* Find out what features are supported */
+ ret = time_pps_getcap(*handle, avail_mode);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get capabilities (%m)\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
+ fprintf(stderr, "cannot CAPTUREASSERT\n");
+ return -1;
+ }
+ if ((*avail_mode & PPS_OFFSETASSERT) == 0) {
+ fprintf(stderr, "cannot OFFSETASSERT\n");
+ return -1;
+ }
+
+ /* Capture assert timestamps, and compensate for a 675 nsec
+ * propagation delay */
+ ret = time_pps_getparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot get parameters (%m)\n");
+ return -1;
+ }
+ params.assert_offset.tv_sec = 0;
+ params.assert_offset.tv_nsec = 675;
+ params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT;
+ ret = time_pps_setparams(*handle, ¶ms);
+ if (ret < 0) {
+ fprintf(stderr, "cannot set parameters (%m)\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int fetch_source(int i, pps_handle_t *handle, int *avail_mode)
+{
+ struct timespec timeout;
+ pps_info_t infobuf;
+ int ret;
+
+ /* create a zero-valued timeout */
+ timeout.tv_sec = 3;
+ timeout.tv_nsec = 0;
+
+retry:
+ if (*avail_mode & PPS_CANWAIT) {
+ /* waits for the next event */
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ } else {
+ sleep(1);
+ ret =
+ time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
+ &timeout);
+ }
+ if (ret < 0) {
+ if (ret == -EINTR) {
+ fprintf(stderr, "time_pps_fetch() got a signal!\n");
+ goto retry;
+ }
+
+ fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);
+ return -1;
+ }
+
+ printf("source %d - "
+ "assert %ld.%09ld, sequence: %ld - "
+ "clear %ld.%09ld, sequence: %ld\n",
+ i,
+ infobuf.assert_timestamp.tv_sec,
+ infobuf.assert_timestamp.tv_nsec,
+ infobuf.assert_sequence,
+ infobuf.clear_timestamp.tv_sec,
+ infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ int num, try_link = 0; /* by default use findsource */
+ char link[STRING_LEN] = "/dev/gps0"; /* just a default device */
+ pps_handle_t handle[4];
+ int avail_mode[4];
+ int i = 0, ret;
+
+ if (argc == 1) {
+ ret = find_source(try_link, link, &handle[0], &avail_mode[0]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+
+ num = 1;
+ } else {
+ for (i = 1; i < argc && i <= 4; i++) {
+ ret = sscanf(argv[i], "%d", &num);
+ if (ret < 1) {
+ try_link = ~0;
+ strncpy(link, argv[i], STRING_LEN);
+ }
+
+ ret =
+ find_source(try_link, link, &handle[i - 1],
+ &avail_mode[i - 1]);
+ if (ret < 0)
+ exit(EXIT_FAILURE);
+ }
+
+ num = i - 1;
+ }
+
+ printf("ok, found %d source(s), now start fetching data...\n", num);
+
+ /* loop, printing the most recent timestamp every second or so */
+ while (1) {
+ for (i = 0; i < num; i++) {
+ ret = fetch_source(i, &handle[i], &avail_mode[i]);
+ if (ret < 0 && errno != ETIMEDOUT)
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ for (; i >= 0; i--)
+ time_pps_destroy(handle[i]);
+
+ return 0;
+}
diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
new file mode 100644
index 0000000..dee1782
--- /dev/null
+++ b/Documentation/pps/timepps.h
@@ -0,0 +1,234 @@
+/*
+ * timepps.h -- PPS API main header
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+#ifndef _SYS_TIMEPPS_H_
+#define _SYS_TIMEPPS_H_
+
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <errno.h>
+#include <linux/pps.h>
+
+/*
+ * New data structures
+ */
+
+struct ntp_fp {
+ unsigned int integral;
+ unsigned int fractional;
+};
+
+union pps_timeu {
+ struct timespec tspec;
+ struct ntp_fp ntpfp;
+ unsigned long longpad[3];
+};
+
+struct pps_info {
+ unsigned long assert_sequence; /* seq. num. of assert event */
+ unsigned long clear_sequence; /* seq. num. of clear event */
+ union pps_timeu assert_tu; /* time of assert event */
+ union pps_timeu clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_params {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ union pps_timeu assert_off_tu; /* offset compensation for assert */
+ union pps_timeu clear_off_tu; /* offset compensation for clear */
+};
+
+typedef int pps_handle_t; /* represents a PPS source */
+typedef unsigned long pps_seq_t; /* sequence number */
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
+typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */
+typedef struct pps_info pps_info_t;
+typedef struct pps_params pps_params_t;
+
+#define assert_timestamp assert_tu.tspec
+#define clear_timestamp clear_tu.tspec
+
+#define assert_timestamp_ntpfp assert_tu.ntpfp
+#define clear_timestamp_ntpfp clear_tu.ntpfp
+
+#define assert_offset assert_off_tu.tspec
+#define clear_offset clear_off_tu.tspec
+
+#define assert_offset_ntpfp assert_off_tu.ntpfp
+#define clear_offset_ntpfp clear_off_tu.ntpfp
+
+/*
+ * The PPS API
+ */
+
+#define PPS_HAVE_FINDSOURCE 1
+#define pps_min(a, b) (a) < (b) ? a : b
+int time_pps_findsource(int index, char *path, int pathlen, char *idstring,
+ int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ data.source = index;
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+ strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+/* Defined iff PPS_HAVE_FINDPATH is defined */
+void time_pps_readlink(char *link, int linklen, char *path, int pathlen)
+{
+ int i;
+
+ i = readlink(link, path, pathlen - 1);
+ if (i <= 0) {
+ /* "link" is not a valid symbolic so we directly use it */
+ strncpy(path, link, linklen <= pathlen ? linklen : pathlen);
+ return;
+ }
+
+ /* Return the file name where "link" points to */
+ path[i] = '\0';
+}
+
+#define PPS_HAVE_FINDPATH 1
+int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen)
+{
+ struct pps_source_data_s data;
+ int ret;
+
+ strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN));
+
+ ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data);
+ if (ret < 0)
+ return ret;
+
+ strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN));
+
+ return data.source;
+}
+
+int time_pps_create(int source, pps_handle_t *handle)
+{
+ if (!handle) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* In LinuxPPS there are no differences between a PPS source and
+ * a PPS handle so we return the same value.
+ */
+ *handle = source;
+
+ return 0;
+}
+
+int time_pps_destroy(pps_handle_t handle)
+{
+ /* Nothing to destroy here */
+
+ return 0;
+}
+
+int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
+{
+ int ret;
+ struct pps_kparams __ppsparams;
+
+ ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+
+ ppsparams->api_version = __ppsparams.api_version;
+ ppsparams->mode = __ppsparams.mode;
+ ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;
+ ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;
+ ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;
+ ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;
+
+ return ret;
+}
+
+int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
+{
+ struct pps_kparams __ppsparams;
+
+ __ppsparams.api_version = ppsparams->api_version;
+ __ppsparams.mode = ppsparams->mode;
+ __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;
+ __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;
+ __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;
+ __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;
+
+ return syscall(__NR_time_pps_getparams, handle, &__ppsparams);
+}
+
+/* Get capabilities for handle */
+int time_pps_getcap(pps_handle_t handle, int *mode)
+{
+ return syscall(__NR_time_pps_getcap, handle, mode);
+}
+
+int time_pps_fetch(pps_handle_t handle, const int tsformat,
+ pps_info_t *ppsinfobuf, const struct timespec *timeout)
+{
+ struct pps_kinfo __ppsinfobuf;
+ struct pps_ktime __timeout;
+ int ret;
+
+ /* Sanity checks */
+ if (tsformat != PPS_TSFMT_TSPEC) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (timeout) {
+ __timeout.sec = timeout->tv_sec;
+ __timeout.nsec = timeout->tv_nsec;
+ }
+
+ ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf,
+ timeout ? &__timeout : NULL);
+
+ ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence;
+ ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence;
+ ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec;
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec;
+ ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec;
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec;
+ ppsinfobuf->current_mode = __ppsinfobuf.current_mode;
+
+ return ret;
+}
+
+int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
+ const int edge, const int tsformat)
+{
+ /* LinuxPPS doesn't implement kernel consumer feature */
+ errno = EOPNOTSUPP;
+ return -1;
+}
+
+#endif /* _SYS_TIMEPPS_H_ */
diff --git a/MAINTAINERS b/MAINTAINERS
index df40a4e..17e9a02 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2903,6 +2903,13 @@ P: Michal Ostrowski
M: mostrows@speakeasy.net
S: Maintained
+PPS SUPPORT
+P: Rodolfo Giometti
+M: giometti@enneenne.com
+W: http://wiki.enneenne.com/index.php/LinuxPPS_support
+L: linuxpps@ml.enneenne.com
+S: Maintained
+
PREEMPTIBLE KERNEL
P: Robert Love
M: rml@tech9.net
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index bf6adce..f1bf4ff 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -323,3 +323,8 @@ ENTRY(sys_call_table)
.long sys_signalfd
.long sys_timerfd
.long sys_eventfd
+ .long sys_time_pps_cmd
+ .long sys_time_pps_getparams /* 325 */
+ .long sys_time_pps_setparams
+ .long sys_time_pps_getcap
+ .long sys_time_pps_fetch
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 050323f..bb54cab 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
source "drivers/spi/Kconfig"
+source "drivers/pps/Kconfig"
+
source "drivers/w1/Kconfig"
source "drivers/hwmon/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index adad2f3..985d495 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/
obj-$(CONFIG_I2O) += message/
obj-$(CONFIG_RTC_LIB) += rtc/
obj-y += i2c/
+obj-$(CONFIG_PPS) += pps/
obj-$(CONFIG_W1) += w1/
obj-$(CONFIG_HWMON) += hwmon/
obj-$(CONFIG_PHONE) += telephony/
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 62051f8..8b2e41f 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -746,6 +746,27 @@ static struct console lpcons = {
#endif /* console on line printer */
+/* Support for PPS signal on the line printer */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+
+static void lp_pps_echo(int source, int event, void *data)
+{
+ struct parport *port = data;
+ unsigned char status = parport_read_status(port);
+
+ /* echo event via SEL bit */
+ parport_write_control(port,
+ parport_read_control(port) | PARPORT_CONTROL_SELECT);
+
+ /* signal no event */
+ if ((status & PARPORT_STATUS_ACK) != 0)
+ parport_write_control(port,
+ parport_read_control(port) & ~PARPORT_CONTROL_SELECT);
+}
+
+#endif
+
/* --- initialisation code ------------------------------------- */
static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
@@ -817,6 +838,37 @@ static int lp_register(int nr, struct parport *port)
}
#endif
+#ifdef CONFIG_PPS_CLIENT_LP
+ snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr);
+
+ /* No PPS support if lp port has no IRQ line */
+ if (port->irq != PARPORT_IRQ_NONE) {
+ strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN);
+
+ port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ port->pps_info.echo = lp_pps_echo;
+
+ port->pps_source = pps_register_source(&(port->pps_info),
+ PPS_CAPTUREASSERT | PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (port->pps_source < 0)
+ dev_err(port->dev,
+ "cannot register PPS source \"%s\"\n",
+ port->pps_info.path);
+ else
+ dev_info(port->dev, "PPS source #%d \"%s\" added\n",
+ port->pps_source, port->pps_info.path);
+ } else {
+ port->pps_source = -1;
+ dev_err(port->dev, "PPS support disabled due port \"%s\" is "
+ "in polling mode\n",
+ port->pps_info.path);
+ }
+#endif
+
return 0;
}
@@ -860,6 +912,14 @@ static void lp_detach (struct parport *port)
console_registered = NULL;
}
#endif /* CONFIG_LP_CONSOLE */
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ if (port->pps_source >= 0) {
+ pps_unregister_source(&(port->pps_info));
+ dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n",
+ port->pps_source, port->pps_info.path);
+ }
+#endif
}
static struct parport_driver lp_driver = {
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 0000000..a00b59a
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,31 @@
+#
+# PPS support configuration
+#
+
+menu "PPS support"
+
+config PPS
+ bool "PPS support"
+ depends on EXPERIMENTAL
+ ---help---
+ PPS (Pulse Per Second) is a special pulse provided by some GPS
+ antennae. Userland can use it to get an high time reference.
+
+ Some antennae's PPS signals are connected with the CD (Carrier
+ Detect) pin of the serial line they use to communicate with the
+ host. In this case use the SERIAL_LINE client support.
+
+ Some antennae's PPS signals are connected with some special host
+ inputs so you have to enable the corresponding client support.
+
+config PPS_DEBUG
+ bool "PPS debugging messages"
+ depends on PPS
+ help
+ Say Y here if you want the PPS support to produce a bunch of debug
+ messages to the system log. Select this if you are having a
+ problem with PPS support and want to see more of what is going on.
+
+source drivers/pps/clients/Kconfig
+
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 0000000..d8ec308
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,11 @@
+#
+# Makefile for the PPS core.
+#
+
+pps_core-objs += pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS) += pps_core.o
+obj-y += clients/
+
+ifeq ($(CONFIG_PPS_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 0000000..58a1e55
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,30 @@
+#
+# PPS clients configuration
+#
+
+if PPS
+
+comment "PPS clients support"
+
+config PPS_CLIENT_KTIMER
+ tristate "Kernel timer client (Testing client, use for debug)"
+ help
+ If you say yes here you get support for a PPS debugging client
+ which uses a kernel timer to generate the PPS signal.
+
+ This driver can also be built as a module. If so, the module
+ will be called ktimer.ko.
+
+config PPS_CLIENT_UART
+ bool "UART serial support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the CD (Carrier Detect) pin of your serial port.
+
+config PPS_CLIENT_LP
+ bool "Parallel printer support"
+ help
+ If you say yes here you get support for a PPS source connected
+ with the interrupt pin of your parallel port.
+
+endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
new file mode 100644
index 0000000..f3c1e39
--- /dev/null
+++ b/drivers/pps/clients/Makefile
@@ -0,0 +1,9 @@
+#
+# Makefile for PPS clients.
+#
+
+obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
+
+ifeq ($(CONFIG_PPS_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c
new file mode 100644
index 0000000..c5d83f5
--- /dev/null
+++ b/drivers/pps/clients/ktimer.c
@@ -0,0 +1,114 @@
+/*
+ * ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+
+#include <linux/pps.h>
+
+/*
+ * Global variables
+ */
+
+static int source;
+static struct timer_list ktimer;
+
+/*
+ * The kernel timer
+ */
+
+static void pps_ktimer_event(unsigned long ptr)
+{
+ pr_info("PPS event at %lu\n", jiffies);
+
+ pps_event(source, PPS_CAPTUREASSERT, NULL);
+
+ mod_timer(&ktimer, jiffies + HZ);
+}
+
+/*
+ * The echo function
+ */
+
+static void pps_ktimer_echo(int source, int event, void *data)
+{
+ pr_info("echo %s %s for source %d\n",
+ event & PPS_CAPTUREASSERT ? "assert" : "",
+ event & PPS_CAPTURECLEAR ? "clear" : "",
+ source);
+}
+
+/*
+ * The PPS info struct
+ */
+
+static struct pps_source_info_s pps_ktimer_info = {
+ name : "ktimer",
+ path : "",
+ mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ echo : pps_ktimer_echo,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+ del_timer_sync(&ktimer);
+ pps_unregister_source(&pps_ktimer_info);
+
+ pr_info("ktimer PPS source unregistered\n");
+}
+
+static int __init pps_ktimer_init(void)
+{
+ int ret;
+
+ ret = pps_register_source(&pps_ktimer_info,
+ PPS_CAPTUREASSERT|PPS_OFFSETASSERT,
+ -1 /* is up to the system */);
+ if (ret < 0) {
+ printk(KERN_ERR "cannot register ktimer source\n");
+ return ret;
+ }
+ source = ret;
+
+ setup_timer(&ktimer, pps_ktimer_event, 0);
+ mod_timer(&ktimer, jiffies + HZ);
+
+ pr_info("ktimer PPS source registered at %d\n", source);
+
+ return 0;
+}
+
+module_init(pps_ktimer_init);
+module_exit(pps_ktimer_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 0000000..7aa32c6
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,222 @@
+/*
+ * kapi.c -- kernel API
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/spinlock.h>
+#include <linux/pps.h>
+
+/*
+ * Local variables
+ */
+
+static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED;
+
+/*
+ * Local functions
+ */
+
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+ ts->nsec += offset->nsec;
+ if (ts->nsec >= NSEC_PER_SEC) {
+ ts->nsec -= NSEC_PER_SEC;
+ ts->sec++;
+ } else if (ts->nsec < 0) {
+ ts->nsec += NSEC_PER_SEC;
+ ts->sec--;
+ }
+ ts->sec += offset->sec;
+}
+
+/*
+ * Exported functions
+ */
+
+int pps_register_source(struct pps_source_info_s *info, int default_params,
+ int try_id)
+{
+ int i = -1, err = 0, ret;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ if (try_id >= 0) {
+ if (pps_is_allocated(try_id)) {
+ printk(KERN_ERR "source id %d busy\n", try_id);
+ err = -EBUSY;
+ goto pps_register_source_exit;
+ }
+ i = try_id;
+ } else {
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (!pps_is_allocated(i))
+ break;
+ if (i >= PPS_MAX_SOURCES) {
+ printk(KERN_ERR "no free source IDs\n");
+ err = -ENOMEM;
+ goto pps_register_source_exit;
+ }
+ }
+
+ /* Sanity checks */
+ if ((info->mode & default_params) != default_params) {
+ printk(KERN_ERR "unsupported default parameters\n");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+ info->echo == NULL) {
+ printk(KERN_ERR "echo function is not defined\n");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ printk(KERN_ERR "unspecified time format\n");
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+
+ spin_lock(&pps_lock);
+
+ /* Init the PPS source main struct */
+ memset(&pps_source[i], 0, sizeof(struct pps_s));
+ pps_source[i].params.api_version = PPS_API_VERS;
+ pps_source[i].params.mode = default_params;
+ init_waitqueue_head(&pps_source[i].queue);
+ pps_source[i].info = info;
+
+ spin_unlock(&pps_lock);
+
+pps_register_source_exit :
+ mutex_unlock(&pps_mutex);
+
+ if (err < 0)
+ return err;
+
+ ret = pps_sysfs_create_source_entry(info, i);
+ if (ret < 0)
+ printk(KERN_ERR "unable to create sysfs entry for source %d\n",
+ i);
+
+ return i;
+}
+EXPORT_SYMBOL(pps_register_source);
+
+void pps_unregister_source(struct pps_source_info_s *info)
+{
+ int i;
+
+ pps_sysfs_remove_source_entry(info);
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) && pps_source[i].info == info)
+ break;
+
+ if (i >= PPS_MAX_SOURCES) {
+ printk(KERN_ERR "warning! Try to unregister an unknown "
+ "PPS source\n");
+ goto pps_unregister_source_exit;
+ }
+
+ spin_lock(&pps_lock);
+
+ /* Deallocate the PPS source */
+ memset(&pps_source[i], 0, sizeof(struct pps_s));
+
+ spin_unlock(&pps_lock);
+
+pps_unregister_source_exit :
+ mutex_unlock(&pps_mutex);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+
+void pps_event(int source, int event, void *data)
+{
+ struct timespec __ts;
+ struct pps_ktime ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&__ts);
+
+ /* ... and translate it to PPS time data struct */
+ ts.sec = __ts.tv_sec;
+ ts.nsec = __ts.tv_nsec;
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
+ printk(KERN_ERR "unknown event (%x) for source %d\n",
+ event, source);
+ return;
+ }
+
+ /* Try to grab the lock, if not we prefere loose the event... */
+ if (!spin_trylock(&pps_lock))
+ return;
+
+ if (!pps_source[source].info) {
+ spin_unlock(&pps_lock);
+ return;
+ }
+
+ /* Must call the echo function? */
+ if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+ pps_source[source].info->echo(source, event, data);
+
+ /* Check the event */
+ pps_source[source].current_mode = pps_source[source].params.mode;
+ if (event & PPS_CAPTUREASSERT) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETASSERT)
+ pps_add_offset(&ts,
+ &pps_source[source].params.assert_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].assert_tu = ts;
+ pps_source[source].assert_sequence++;
+ pr_debug("capture assert seq #%u for source %d\n",
+ pps_source[source].assert_sequence, source);
+ }
+ if (event & PPS_CAPTURECLEAR) {
+ /* We have to add an offset? */
+ if (pps_source[source].params.mode & PPS_OFFSETCLEAR)
+ pps_add_offset(&ts,
+ &pps_source[source].params.clear_off_tu);
+
+ /* Save the time stamp */
+ pps_source[source].clear_tu = ts;
+ pps_source[source].clear_sequence++;
+ pr_debug("capture clear seq #%u for source %d\n",
+ pps_source[source].clear_sequence, source);
+ }
+
+ pps_source[source].go = ~0;
+ wake_up_interruptible(&pps_source[source].queue);
+
+ spin_unlock(&pps_lock);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 0000000..9176c01
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,391 @@
+/*
+ * pps.c -- Main PPS support file
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/linkage.h>
+#include <linux/sched.h>
+#include <linux/pps.h>
+#include <linux/uaccess.h>
+
+/*
+ * Global variables
+ */
+
+struct pps_s pps_source[PPS_MAX_SOURCES];
+DEFINE_MUTEX(pps_mutex);
+
+/*
+ * Misc functions
+ */
+
+static inline int pps_check_source(int source)
+{
+ return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0;
+}
+
+static int pps_find_source(int source)
+{
+ int i;
+
+ if (source >= 0) {
+ if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source))
+ return -EINVAL;
+ else
+ return source;
+ }
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+static int pps_find_path(char *path)
+{
+ int i;
+
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ if (pps_is_allocated(i) &&
+ (strncmp(pps_source[i].info->path, path,
+ PPS_MAX_NAME_LEN) == 0 ||
+ strncmp(pps_source[i].info->name, path,
+ PPS_MAX_NAME_LEN) == 0))
+ break;
+
+ if (i >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ return i;
+}
+
+/*
+ * PPS System Calls
+ */
+
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg)
+{
+ struct pps_source_data_s data;
+ int ret = 0;
+
+ pr_debug("%s: cmd %d\n", __FUNCTION__, cmd);
+
+ /* Sanity checks */
+ if (_IOC_TYPE(cmd) != 'P')
+ return -EOPNOTSUPP;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ switch (cmd) {
+ case PPS_CMD_FIND_SRC :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pr_debug("PPS_CMD_FIND_SRC: source %d\n", data.source);
+
+ data.source = pps_find_source(data.source);
+ if (data.source < 0) {
+ pr_debug("no PPS devices found\n");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ case PPS_CMD_FIND_PATH :
+ ret = copy_from_user(&data, arg,
+ sizeof(struct pps_source_data_s));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ pr_debug("PPS_CMD_FIND_PATH: path %s\n", data.path);
+
+ data.source = pps_find_path(data.path);
+ if (data.source < 0) {
+ pr_debug("no PPS devices found\n");
+ ret = -ENODEV;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ break;
+
+ default :
+ printk(KERN_ERR "invalid sys_time_pps_cmd %d\n", cmd);
+ ret = -EOPNOTSUPP;
+ goto sys_time_pps_cmd_exit;
+ }
+
+ /* Found! So copy the info */
+ strncpy(data.name, pps_source[data.source].info->name,
+ PPS_MAX_NAME_LEN);
+ strncpy(data.path, pps_source[data.source].info->path,
+ PPS_MAX_NAME_LEN);
+
+ ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_cmd_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params)
+{
+ int ret = 0;
+
+ pr_debug("%s: source %d\n", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getparams_exit;
+ }
+
+ /* Return current parameters */
+ ret = copy_to_user(params, &pps_source[source].params,
+ sizeof(struct pps_kparams));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_getparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params)
+{
+ int ret;
+
+ pr_debug("%s: source %d\n", __FUNCTION__, source);
+
+ /* Check the capabilities */
+ if (!capable(CAP_SYS_TIME))
+ return -EPERM;
+
+ /* Sanity checks */
+ if (!params)
+ return -EINVAL;
+ if ((params->mode & ~pps_source[source].info->mode) != 0) {
+ pr_debug("unsupported capabilities\n");
+ return -EINVAL;
+ }
+ if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+ pr_debug("capture mode unspecified\n");
+ return -EINVAL;
+ }
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Save the new parameters */
+ ret = copy_from_user(&pps_source[source].params, params,
+ sizeof(struct pps_kparams));
+ if (ret) {
+ ret = -EFAULT;
+ goto sys_time_pps_setparams_exit;
+ }
+
+ /* Restore the read only parameters */
+ if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ /* section 3.3 of RFC 2783 interpreted */
+ pr_debug("time format unspecified\n");
+ pps_source[source].params.mode |= PPS_TSFMT_TSPEC;
+ }
+ if (pps_source[source].info->mode & PPS_CANWAIT)
+ pps_source[source].params.mode |= PPS_CANWAIT;
+ pps_source[source].params.api_version = PPS_API_VERS;
+
+sys_time_pps_setparams_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode)
+{
+ int ret;
+
+ pr_debug("%s: source %d\n", __FUNCTION__, source);
+
+ /* Sanity checks */
+ if (!mode)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_getcap_exit;
+ }
+
+ ret = put_user(pps_source[source].info->mode, mode);
+
+sys_time_pps_getcap_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout)
+{
+ unsigned long ticks;
+ struct pps_kinfo pi;
+ struct pps_ktime to;
+ int ret;
+
+ pr_debug("%s: source %d\n", __FUNCTION__, source);
+
+ if (!info)
+ return -EINVAL;
+
+ if (mutex_lock_interruptible(&pps_mutex))
+ return -EINTR;
+
+ ret = pps_check_source(source);
+ if (ret < 0) {
+ ret = -ENODEV;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ pps_source[source].go = 0;
+
+ /* Manage the timeout */
+ if (timeout) {
+ ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime));
+ if (ret) {
+ goto sys_time_pps_fetch_exit;
+ ret = -EFAULT;
+ }
+ pr_debug("timeout %lld.%09d\n", to.sec, to.nsec);
+ ticks = to.sec * HZ;
+ ticks += to.nsec / (NSEC_PER_SEC / HZ);
+
+ if (ticks != 0) {
+ ret = wait_event_interruptible_timeout(
+ pps_source[source].queue,
+ pps_source[source].go, ticks);
+ if (ret == 0) {
+ pr_debug("timeout expired\n");
+ ret = -ETIMEDOUT;
+ goto sys_time_pps_fetch_exit;
+ }
+ }
+ } else
+ ret = wait_event_interruptible(pps_source[source].queue,
+ pps_source[source].go);
+
+ /* Check for pending signals */
+ if (ret == -ERESTARTSYS) {
+ pr_debug("pending signal caught\n");
+ ret = -EINTR;
+ goto sys_time_pps_fetch_exit;
+ }
+
+ /* Return the fetched timestamp */
+ pi.assert_sequence = pps_source[source].assert_sequence;
+ pi.clear_sequence = pps_source[source].clear_sequence;
+ pi.assert_tu = pps_source[source].assert_tu;
+ pi.clear_tu = pps_source[source].clear_tu;
+ pi.current_mode = pps_source[source].current_mode;
+ ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo));
+ if (ret)
+ ret = -EFAULT;
+
+sys_time_pps_fetch_exit:
+ mutex_unlock(&pps_mutex);
+
+ return ret;
+}
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_exit(void)
+{
+ pps_sysfs_unregister();
+
+ pr_info("LinuxPPS API ver. %d removed\n", PPS_API_VERS);
+}
+
+static int __init pps_init(void)
+{
+ int i, ret;
+
+ /* Init pps_source info */
+ for (i = 0; i < PPS_MAX_SOURCES; i++)
+ memset(&pps_source[i], 0, sizeof(struct pps_s));
+
+ /* Register to sysfs */
+ ret = pps_sysfs_register();
+ if (ret < 0) {
+ printk(KERN_ERR "unable to register sysfs\n");
+ return ret;
+ }
+
+ pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS);
+ pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+ "<giometti@linux.it>\n", PPS_VERSION);
+
+ return 0;
+}
+
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
new file mode 100644
index 0000000..e52dd8e
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,217 @@
+/*
+ * sysfs.c -- sysfs support
+ *
+ *
+ * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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 <linux/device.h>
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <linux/pps.h>
+
+/*
+ * Private functions
+ */
+
+static ssize_t pps_show_assert(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->assert_tu.sec, dev->assert_tu.nsec,
+ dev->assert_sequence);
+}
+
+static ssize_t pps_show_clear(struct class_device *cdev, char *buf)
+{
+ struct pps_s *dev = class_get_devdata(cdev);
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ dev->clear_tu.sec, dev->clear_tu.nsec,
+ dev->clear_sequence);
+}
+
+static ssize_t pps_show_mode(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%4x\n", info->mode);
+}
+
+static ssize_t pps_show_echo(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%d\n", !!info->echo);
+}
+
+static ssize_t pps_show_name(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->name);
+}
+
+static ssize_t pps_show_path(struct class_device *cdev, char *buf)
+{
+ struct pps_source_info_s *info = to_pps_info(cdev);
+
+ return sprintf(buf, "%s\n", info->path);
+}
+
+/*
+ * Files definitions
+ */
+
+#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \
+{ \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = _mode, \
+ .owner = THIS_MODULE, \
+ }, \
+ .show = _show, \
+ .store = _store, \
+}
+
+static struct class_device_attribute pps_class_device_attributes[] = {
+ DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL),
+ DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL),
+ DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL),
+ DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL),
+ DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL),
+ DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL),
+};
+
+/*
+ * Class definitions
+ */
+
+static void pps_class_release(struct class_device *cdev)
+{
+ /* Nop??? */
+}
+
+static struct class pps_class = {
+ .name = "pps",
+ .release = pps_class_release,
+};
+
+/*
+ * Public functions
+ */
+
+void pps_sysfs_remove_source_entry(struct pps_source_info_s *info)
+{
+ int i;
+
+ /* Sanity checks */
+ if (info == NULL)
+ return;
+
+ /* Delete info files */
+ if (info->mode&PPS_CAPTUREASSERT)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+
+ if (info->mode&PPS_CAPTURECLEAR)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ /* Deregister the pps class */
+ class_device_unregister(&info->class_dev);
+}
+
+int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id)
+{
+ char buf[32];
+ int i, ret;
+
+ /* Sanity checks */
+ if (info == NULL || id >= PPS_MAX_SOURCES)
+ return -EINVAL;
+
+ /* Create dir class device name */
+ sprintf(buf, "%.02d", id);
+
+ /* Setup the class struct */
+ memset(&info->class_dev, 0, sizeof(struct class_device));
+ info->class_dev.class = &pps_class;
+ strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN);
+ class_set_devdata(&info->class_dev, &pps_source[id]);
+
+ /* Register the new class */
+ ret = class_device_register(&info->class_dev);
+ if (unlikely(ret))
+ goto error_class_device_register;
+
+ /* Create info files */
+
+ /* Create file "assert" and "clear" according to source capability */
+ if (info->mode & PPS_CAPTUREASSERT) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[0]);
+ i = 0;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+ if (info->mode & PPS_CAPTURECLEAR) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[1]);
+ i = 1;
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) {
+ ret = class_device_create_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+ if (unlikely(ret))
+ goto error_class_device_create_file;
+ }
+
+ return 0;
+
+error_class_device_create_file:
+ while (--i >= 0)
+ class_device_remove_file(&info->class_dev,
+ &pps_class_device_attributes[i]);
+
+ class_device_unregister(&info->class_dev);
+ /* Here the release() method was already called */
+
+error_class_device_register:
+
+ return ret;
+}
+
+void pps_sysfs_unregister(void)
+{
+ class_unregister(&pps_class);
+}
+
+int pps_sysfs_register(void)
+{
+ return class_register(&pps_class);
+}
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c84dab0..0c9a307 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
up->ier |= UART_IER_MSI;
if (up->capabilities & UART_CAP_UUE)
up->ier |= UART_IER_UUE | UART_IER_RTOIE;
+ if (up->port.flags & UPF_HARDPPS_CD)
+ up->ier |= UART_IER_MSI; /* enable interrupts */
serial_out(up, UART_IER, up->ier);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 326020f..cc5b4fc 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -33,6 +33,7 @@
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
#include <linux/delay.h>
#include <linux/mutex.h>
+#include <linux/pps.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
@@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state,
return 0;
}
+#ifdef CONFIG_PPS_CLIENT_UART
+
+static int
+uart_register_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ struct tty_driver *drv = port->info->tty->driver;
+ int ret;
+
+ snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d",
+ drv->driver_name, port->line);
+ snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d",
+ drv->name, port->line);
+
+ state->pps_info.mode = PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR,
+ -1 /* PPS ID is up to the system */);
+ if (ret < 0) {
+ dev_err(port->dev, "cannot register PPS source \"%s\"\n",
+ state->pps_info.path);
+ return ret;
+ }
+ port->pps_source = ret;
+ dev_dbg(port->dev, "PPS source #%d \"%s\" added\n",
+ port->pps_source, state->pps_info.path);
+
+ return 0;
+}
+
+static void
+uart_unregister_pps_port(struct uart_state *state, struct uart_port *port)
+{
+ pps_unregister_source(&state->pps_info);
+ dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n",
+ port->pps_source, state->pps_info.path);
+}
+
+#else
+
+#define uart_register_pps_port(state, port) do { } while (0)
+#define uart_unregister_pps_port(state, port) do { } while (0)
+
+#endif /* CONFIG_PPS_CLIENT_UART */
+
static int uart_set_info(struct uart_state *state,
struct serial_struct __user *newinfo)
{
@@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state,
(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
check_and_exit:
+ /* PPS support enabled/disabled? */
+ if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) {
+ if (new_flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+ else
+ uart_unregister_pps_port(state, port);
+ }
+
retval = 0;
if (port->type == PORT_UNKNOWN)
goto exit;
if (state->info->flags & UIF_INITIALIZED) {
- if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
+ if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) ||
old_custom_divisor != port->custom_divisor) {
/*
* If they're setting up a custom divisor or speed,
@@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
port->ops->config_port(port, flags);
}
+ /*
+ * Add the PPS support for the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_register_pps_port(state, port);
+
if (port->type != PORT_UNKNOWN) {
unsigned long flags;
@@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
mutex_unlock(&state->mutex);
/*
+ * Remove PPS support from the current port.
+ */
+ if (port->flags & UPF_HARDPPS_CD)
+ uart_unregister_pps_port(state, port);
+
+ /*
* Remove the devices from the tty layer
*/
tty_unregister_device(drv->tty_driver, port->line);
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index e84ace1..36746dc 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -329,10 +329,15 @@
#define __NR_signalfd 321
#define __NR_timerfd 322
#define __NR_eventfd 323
+#define __NR_time_pps_cmd 324
+#define __NR_time_pps_getparams 325
+#define __NR_time_pps_setparams 326
+#define __NR_time_pps_getcap 327
+#define __NR_time_pps_fetch 328
#ifdef __KERNEL__
-#define NR_syscalls 324
+#define NR_syscalls 329
#define __ARCH_WANT_IPC_PARSE_VERSION
#define __ARCH_WANT_OLD_READDIR
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index f317c27..a10d20a 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -293,6 +293,7 @@ unifdef-y += pmu.h
unifdef-y += poll.h
unifdef-y += ppp_defs.h
unifdef-y += ppp-comp.h
+unifdef-y += pps.h
unifdef-y += ptrace.h
unifdef-y += qnx4_fs.h
unifdef-y += quota.h
diff --git a/include/linux/parport.h b/include/linux/parport.h
index 9cdd694..0ecce1f 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -100,6 +100,7 @@ typedef enum {
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
+#include <linux/pps.h>
#include <asm/system.h>
#include <asm/ptrace.h>
#include <asm/semaphore.h>
@@ -327,6 +328,11 @@ struct parport {
struct list_head full_list;
struct parport *slaves[3];
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ struct pps_source_info_s pps_info;
+ int pps_source; /* PPS source ID */
+#endif
};
#define DEFAULT_SPIN_TIME 500 /* us */
@@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode);
/* Lowlevel drivers _can_ call this support function to handle irqs. */
static __inline__ void parport_generic_irq(int irq, struct parport *port)
{
+#ifdef CONFIG_PPS_CLIENT_LP
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ dev_dbg(port->dev, "PPS assert at %lu on source #%d\n",
+ jiffies, port->pps_source);
+#endif
+
parport_ieee1284_interrupt (irq, port);
read_lock(&port->cad_lock);
if (port->cad && port->cad->irq_func)
diff --git a/include/linux/pps.h b/include/linux/pps.h
new file mode 100644
index 0000000..6eca3ea
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,206 @@
+/*
+ * pps.h -- PPS API kernel header.
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
+ *
+ * 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.
+ */
+
+
+#ifndef _PPS_H_
+#define _PPS_H_
+
+/* Implementation note: the logical states ``assert'' and ``clear''
+ * are implemented in terms of the chip register, i.e. ``assert''
+ * means the bit is set. */
+
+/*
+ * 3.2 New data structures
+ */
+
+#ifndef __KERNEL__
+#include <linux/types.h>
+#include <sys/time.h>
+#else
+#include <linux/time.h>
+#endif
+
+#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */
+#define PPS_API_VERS PPS_API_VERS_2
+#define LINUXPSS_API 1 /* mark LinuxPPS API */
+
+#define PPS_MAX_NAME_LEN 32
+
+/* 32-bit vs. 64-bit compatibility.
+ *
+ * 0n i386, the alignment of a uint64_t is only 4 bytes, while on most other
+ * architectures it's 8 bytes. On i386, there will be no padding between the
+ * two consecutive 'struct pps_ktime' members of struct pps_kinfo and struct
+ * pps_kparams. But on most platforms there will be padding to ensure correct
+ * alignment.
+ *
+ * The simple fix is probably to add an explicit padding.
+ * [David Woodhouse]
+ */
+struct pps_ktime {
+ __u64 sec;
+ __u32 nsec;
+ __u32 padding;
+};
+
+struct pps_kinfo {
+ __u32 assert_sequence; /* seq. num. of assert event */
+ __u32 clear_sequence; /* seq. num. of clear event */
+ struct pps_ktime assert_tu; /* time of assert event */
+ struct pps_ktime clear_tu; /* time of clear event */
+ int current_mode; /* current mode bits */
+};
+
+struct pps_kparams {
+ int api_version; /* API version # */
+ int mode; /* mode bits */
+ struct pps_ktime assert_off_tu; /* offset compensation for assert */
+ struct pps_ktime clear_off_tu; /* offset compensation for clear */
+};
+
+/*
+ * 3.3 Mode bit definitions
+ */
+
+/* Device/implementation parameters */
+#define PPS_CAPTUREASSERT 0x01 /* capture assert events */
+#define PPS_CAPTURECLEAR 0x02 /* capture clear events */
+#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
+
+#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
+#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
+
+#define PPS_CANWAIT 0x100 /* can we wait for an event? */
+#define PPS_CANPOLL 0x200 /* bit reserved for future use */
+
+/* Kernel actions */
+#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
+#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
+
+/* Timestamp formats */
+#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
+#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
+
+/*
+ * 3.4.4 New functions: disciplining the kernel timebase
+ */
+
+/* Kernel consumers */
+#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */
+#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to
+ use a phase-locked loop */
+#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to
+ use a frequency-locked loop */
+/*
+ * Here begins the implementation-specific part!
+ */
+
+#include <linux/ioctl.h>
+
+struct pps_source_data_s {
+ int source;
+ char name[PPS_MAX_NAME_LEN];
+ char path[PPS_MAX_NAME_LEN];
+};
+
+#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *)
+#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *)
+
+#ifdef __KERNEL__
+
+#include <linux/device.h>
+
+/*
+ * Misc macros
+ */
+
+#define PPS_VERSION "4.0.0-rc4"
+
+/*
+ * Global defines
+ */
+
+#define PPS_MAX_SOURCES 16
+
+/* The specific PPS source info */
+struct pps_source_info_s {
+ char name[PPS_MAX_NAME_LEN]; /* simbolic name */
+ char path[PPS_MAX_NAME_LEN]; /* path of connected device */
+ int mode; /* PPS's allowed mode */
+
+ void (*echo)(int source, int event, void *data); /* PPS echo function */
+
+ /* sysfs section */
+ struct class_device class_dev;
+};
+
+/* The main struct */
+struct pps_s {
+ struct pps_source_info_s *info; /* PSS source info */
+
+ struct pps_kparams params; /* PPS's current params */
+
+ __u32 assert_sequence; /* PPS' assert event seq # */
+ __u32 clear_sequence; /* PPS' clear event seq # */
+ struct pps_ktime assert_tu;
+ struct pps_ktime clear_tu;
+ int current_mode; /* PPS mode at event time */
+
+ int go; /* PPS event is arrived? */
+ wait_queue_head_t queue; /* PPS event queue */
+};
+
+/*
+ * Global variables
+ */
+
+extern struct pps_s pps_source[PPS_MAX_SOURCES];
+extern struct mutex pps_mutex;
+
+/*
+ * Global functions
+ */
+
+static inline int pps_is_allocated(int source)
+{
+ return pps_source[source].info != NULL;
+}
+
+#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev)
+
+/*
+ * Exported functions
+ */
+
+extern int pps_register_source(struct pps_source_info_s *info,
+ int default_params, int try_id);
+extern void pps_unregister_source(struct pps_source_info_s *info);
+extern void pps_event(int source, int event, void *data);
+
+extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info,
+ int id);
+extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info);
+extern int pps_sysfs_register(void);
+extern void pps_sysfs_unregister(void);
+
+#endif /* __KERNEL__ */
+
+#endif /* _PPS_H_ */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 7f2c99d..01f3459 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -153,6 +153,7 @@
#include <linux/tty.h>
#include <linux/mutex.h>
#include <linux/sysrq.h>
+#include <linux/pps.h>
struct uart_port;
struct uart_info;
@@ -232,6 +233,9 @@ struct uart_port {
unsigned char regshift; /* reg offset shift */
unsigned char iotype; /* io access style */
unsigned char unused1;
+#ifdef CONFIG_PPS_CLIENT_UART
+ int pps_source; /* PPS source ID */
+#endif
#define UPIO_PORT (0)
#define UPIO_HUB6 (1)
@@ -276,7 +280,8 @@ struct uart_port {
#define UPF_IOREMAP ((__force upf_t) (1 << 31))
#define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))
-#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
+#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\
+ |UPF_HARDPPS_CD))
unsigned int mctrl; /* current modem ctrl settings */
unsigned int timeout; /* character-based timeout */
@@ -308,6 +313,10 @@ struct uart_state {
struct uart_info *info;
struct uart_port *port;
+#ifdef CONFIG_PPS_CLIENT_UART
+ struct pps_source_info_s pps_info;
+#endif
+
struct mutex mutex;
};
@@ -472,13 +481,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
- port->icount.dcd++;
-
-#ifdef CONFIG_HARD_PPS
- if ((port->flags & UPF_HARDPPS_CD) && status)
- hardpps();
+#ifdef CONFIG_PPS_CLIENT_UART
+ if (port->flags & UPF_HARDPPS_CD) {
+ if (status) {
+ pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
+ dev_dbg(port->dev, "PPS assert at %lu on source #%d\n",
+ jiffies, port->pps_source);
+ } else {
+ pps_event(port->pps_source, PPS_CAPTURECLEAR, port);
+ dev_dbg(port->dev, "PPS clear at %lu on source #%d\n",
+ jiffies, port->pps_source);
+ }
+ }
#endif
+ port->icount.dcd++;
+
if (info->flags & UIF_CHECK_CD) {
if (status)
wake_up_interruptible(&info->open_wait);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 83d0ec1..bfc8899 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -65,6 +65,7 @@ struct getcpu_cache;
#include <asm/signal.h>
#include <linux/quota.h>
#include <linux/key.h>
+#include <linux/pps.h>
asmlinkage long sys_time(time_t __user *tloc);
asmlinkage long sys_stime(time_t __user *tptr);
@@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags,
const struct itimerspec __user *utmr);
asmlinkage long sys_eventfd(unsigned int count);
+asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg);
+asmlinkage long sys_time_pps_getparams(int source,
+ struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_setparams(int source,
+ const struct pps_kparams __user *params);
+asmlinkage long sys_time_pps_getcap(int source, int __user *mode);
+asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info,
+ const struct pps_ktime __user *timeout);
+
int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 7e11e2c..e0fccc2 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -148,3 +148,10 @@ cond_syscall(sys_timerfd);
cond_syscall(compat_sys_signalfd);
cond_syscall(compat_sys_timerfd);
cond_syscall(sys_eventfd);
+
+/* PPS dependent */
+cond_syscall(sys_time_pps_find);
+cond_syscall(sys_time_pps_getparams);
+cond_syscall(sys_time_pps_setparams);
+cond_syscall(sys_time_pps_getcap);
+cond_syscall(sys_time_pps_fetch);
^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti
@ 2007-07-27 19:08 ` Chris Friesen
2007-07-27 19:28 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Chris Friesen @ 2007-07-27 19:08 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton
Rodolfo Giometti wrote:
> The pps_event() is now protected by a spinlock against
> pps_register_source() and pps_unregister_source()...
Locks protect data, not code. It may make more sense to identify the
specific data being protected by the spinlock.
Chris
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 19:08 ` Chris Friesen
@ 2007-07-27 19:28 ` Rodolfo Giometti
2007-07-27 19:40 ` Chris Friesen
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-27 19:28 UTC (permalink / raw)
To: Chris Friesen; +Cc: David Woodhouse, linux-kernel, Andrew Morton
On Fri, Jul 27, 2007 at 01:08:58PM -0600, Chris Friesen wrote:
> Rodolfo Giometti wrote:
>
>> The pps_event() is now protected by a spinlock against
>> pps_register_source() and pps_unregister_source()...
>
> Locks protect data, not code. It may make more sense to identify the
> specific data being protected by the spinlock.
What do you mean? Did you find an error into my patch? :-o
Functions pps_event() and
pps_register_source()/pps_unregister_source() take accesso to shared
data, that's why I used spinlocks.
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 19:28 ` Rodolfo Giometti
@ 2007-07-27 19:40 ` Chris Friesen
2007-07-27 19:45 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Chris Friesen @ 2007-07-27 19:40 UTC (permalink / raw)
To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton
Rodolfo Giometti wrote:
> What do you mean? Did you find an error into my patch? :-o
>
> Functions pps_event() and
> pps_register_source()/pps_unregister_source() take accesso to shared
> data, that's why I used spinlocks.
My point is that the lock should be used to protect specific data.
Thus, it would be more correct to say, "spinlock foo is taken because
pps_register_source() accesses variable bar".
That way, if someone else wants to access "bar", they know that they
need to take lock "foo".
Chris
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 19:40 ` Chris Friesen
@ 2007-07-27 19:45 ` Rodolfo Giometti
2007-07-27 20:47 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-27 19:45 UTC (permalink / raw)
To: Chris Friesen; +Cc: David Woodhouse, linux-kernel, Andrew Morton
On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote:
>
> My point is that the lock should be used to protect specific data. Thus, it
> would be more correct to say, "spinlock foo is taken because
> pps_register_source() accesses variable bar".
>
> That way, if someone else wants to access "bar", they know that they need
> to take lock "foo".
Ah, ok! I see. :)
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 19:45 ` Rodolfo Giometti
@ 2007-07-27 20:47 ` Satyam Sharma
2007-07-27 23:41 ` Satyam Sharma
2007-07-29 9:17 ` Rodolfo Giometti
0 siblings, 2 replies; 43+ messages in thread
From: Satyam Sharma @ 2007-07-27 20:47 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi Rodolfo,
On 7/28/07, Rodolfo Giometti <giometti@enneenne.com> wrote:
> On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote:
> >
> > My point is that the lock should be used to protect specific data. Thus, it
> > would be more correct to say, "spinlock foo is taken because
> > pps_register_source() accesses variable bar".
> >
> > That way, if someone else wants to access "bar", they know that they need
> > to take lock "foo".
>
> Ah, ok! I see. :)
I only glanced through the code, so could be wrong, but I noticed that
the only global / shared data you have in there is a global "pps_source"
array of pps_s structs. That's accessed / modified from the various
syscalls introduced in the API exported to userspace, as well as the
register/unregister/pps_event API exported to in-kernel client subsystems,
yes? So it looks like you need to introduce proper locking for it, simply
type-qualifying it as "volatile" is not enough.
However, I think you've introduced two locks for it. The syscalls (that
run in process context, obviously) seem to use a pps_mutex and
pps_event() seems to be using the pps_lock spinlock (because that
gets executed from interrupt context) -- and from the looks of it, the
register/unregister functions are using /both/ the mutex and spinlock (!)
This isn't quite right, (in fact there's nothing to protect pps_event from
racing against a syscall), so you should use *only* the spinlock for
synchronization -- the spin_lock_irqsave/restore() variants, in fact.
[ Also, have you considered making pps_source a list and not an array?
It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
kind of gymnastics in there, and you _can_ return a pointer to the
corresponding pps source struct from the register() function to the in-kernel
users, so that way you get to retain the O(1) access to the corresponding
source when a client calls into pps_event(), similar to how you're using the
array index presently. ]
I also noticed code like (from pps_event):
+ /* Try to grab the lock, if not we prefere loose the event... */
+ if (!spin_trylock(&pps_lock))
+ return;
which looks worrisome and unnecessary. That spinlock looks to be of
fine enough granularity to me, do you think there'd be any contention
on it? I /think/ you can simply make that a spin_lock().
Overall the code looks simple / straightforward enough to me (except for
the parport / uart stuff that I have no clue about), and I'll also read up on
the relevant RFC for this and would hopefully try and give you a more
meaningful review over the weekend.
Thanks,
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 20:47 ` Satyam Sharma
@ 2007-07-27 23:41 ` Satyam Sharma
2007-07-29 9:50 ` Rodolfo Giometti
` (2 more replies)
2007-07-29 9:17 ` Rodolfo Giometti
1 sibling, 3 replies; 43+ messages in thread
From: Satyam Sharma @ 2007-07-27 23:41 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi,
On 7/28/07, Satyam Sharma <satyam.sharma@gmail.com> wrote:
> Hi Rodolfo,
>
> On 7/28/07, Rodolfo Giometti <giometti@enneenne.com> wrote:
> > On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote:
> > >
> > > My point is that the lock should be used to protect specific data. Thus, it
> > > would be more correct to say, "spinlock foo is taken because
> > > pps_register_source() accesses variable bar".
> > >
> > > That way, if someone else wants to access "bar", they know that they need
> > > to take lock "foo".
> >
> > Ah, ok! I see. :)
>
> I only glanced through the code, so could be wrong, but I noticed that
> the only global / shared data you have in there is a global "pps_source"
> array of pps_s structs. That's accessed / modified from the various
> syscalls introduced in the API exported to userspace, as well as the
> register/unregister/pps_event API exported to in-kernel client subsystems,
> yes? So it looks like you need to introduce proper locking for it, simply
> type-qualifying it as "volatile" is not enough.
>
> However, I think you've introduced two locks for it. The syscalls (that
> run in process context, obviously) seem to use a pps_mutex and
> pps_event() seems to be using the pps_lock spinlock (because that
> gets executed from interrupt context) -- and from the looks of it, the
> register/unregister functions are using /both/ the mutex and spinlock (!)
>
> This isn't quite right, (in fact there's nothing to protect pps_event from
> racing against a syscall), so you should use *only* the spinlock for
> synchronization -- the spin_lock_irqsave/restore() variants, in fact.
Take the race between the time_pps_setparams() syscall and a concurrent
pps_event() from an interrupt for instance. From sys_time_pps_setparams,
the parameters for an existing source are not modified / set atomically,
which means a pps_event() called on the same source in between will see
invalid parameters ... and bad things will happen.
> [ Also, have you considered making pps_source a list and not an array?
> It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
> kind of gymnastics in there, and you _can_ return a pointer to the
> corresponding pps source struct from the register() function to the in-kernel
> users, so that way you get to retain the O(1) access to the corresponding
> source when a client calls into pps_event(), similar to how you're using the
> array index presently. ]
I think the above would be sane and safe -- your driver has pretty simple
lifetime rules, and "sources" are only created / destroyed from within kernel,
as and when clients call pps_register_source() and pps_unregister_source().
So pps_event() can be called on a given source only between the
corresponding register() and unregister() -- which means register() can
return us a reference/pointer on the source after allocating / adding it to
the list (instead of the fixed array index as it presently is), which remains
valid for the entire duration of the source, till unregister() is called, after
which we can't be calling pps_event() on the same source anyway.
> I also noticed code like (from pps_event):
>
> + /* Try to grab the lock, if not we prefere loose the event... */
> + if (!spin_trylock(&pps_lock))
> + return;
>
> which looks worrisome and unnecessary. That spinlock looks to be of
> fine enough granularity to me, do you think there'd be any contention
> on it? I /think/ you can simply make that a spin_lock().
>
> Overall the code looks simple / straightforward enough to me (except for
> the parport / uart stuff that I have no clue about), and I'll also read up on
> the relevant RFC for this and would hopefully try and give you a more
> meaningful review over the weekend.
Ok, I've looked through (most of) the RFC and code now, and am only
commenting on a design-level for now. Anyway, I didn't like the way
you've significantly drifted from the RFC in several ways:
1. The RFC mandates no such userspace interface / syscall as the
time_pps_cmd() that you've implemented -- it looks, smells, and feels
like an ioctl, in fact that's what it is for practical purposes. I'm confused
as to why didn't you just go ahead and implement the special-file-and-
file-descriptor based approach as advocated / mandated there.
[ You've implemented the (optional, as per RFC) time_pps_findsource
operation in the kernel using the above "pseudo-ioctl", but that wasn't
necessary -- as the RFC itself illustrates, it's something that can easily
be done (in fact should be done) completely in userspace itself. ]
2. If you fix the above two issues, you'll notice that you don't need to
short-circuit the (RFC-mandated) time_pps_create/destroy(handle)
syscalls in the userspace header/library anymore, as you presently are.
Here's how I'd go about desiging/implementing this:
* At the time of pps_register_source() -- called by an in-kernel client
subsystem that creates a PPS source -- allocate a pps source, generate
an identifier for it, instantiate a special file -- the RFC does not mention
whether a char or block device, but char device (I noticed an example
in the RFC where they've used /dev/ppsXX as a possible path) would be
proper for this. Finally add it to the list of sources. This returns a
reference/pointer on that source back to the in-kernel client, which then
passes *that* to pps_event(), similar to how you're presently using the
array index.
[ The way you've passed the path of the parport/uart device itself
(/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source()
in pps_info.path doesn't quite look right to me. Note that the userspace is
expected to open(2) the special file corresponding to the *PPS* source,
as instantiated from the above code, and not the /dev/xyz special file of
the *physical* port through which a pulse-generating device may be
connected to the PC. ]
* Userspace will open(2) the special file, and get an fd. Then calls the
time_pps_create(fd, &handle) syscall -- kernel will find the pps source
that matches that passed fd from the list of sources, and instantiates a
"handle" associated with that source and returns that back to userspace.
The rest would happen as usual / as you've currently implemented.
I /think/ the RFC does envision such an implementation, so it helps us
comply with that standard, and would also get rid of a lot of kludgy
"findpath" and "findsource" stuff that we otherwise have to do in-kernel
and userspace, as we're presently doing in the patch.
[ BTW, it would be nice if you submit this stuff as a patchset that brings
in functionality over a series of multiple patches -- the sysfs interface bits
can be introduced in a different patch from the syscalls, which can be
introduced in a different patch from the kernel-side API, etc ... that helps
a code-level review. ]
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 20:47 ` Satyam Sharma
2007-07-27 23:41 ` Satyam Sharma
@ 2007-07-29 9:17 ` Rodolfo Giometti
2007-07-30 4:19 ` Satyam Sharma
1 sibling, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-29 9:17 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Sat, Jul 28, 2007 at 02:17:24AM +0530, Satyam Sharma wrote:
>
> I only glanced through the code, so could be wrong, but I noticed that
> the only global / shared data you have in there is a global "pps_source"
> array of pps_s structs. That's accessed / modified from the various
> syscalls introduced in the API exported to userspace, as well as the
> register/unregister/pps_event API exported to in-kernel client subsystems,
> yes? So it looks like you need to introduce proper locking for it, simply
> type-qualifying it as "volatile" is not enough.
>
> However, I think you've introduced two locks for it. The syscalls (that
> run in process context, obviously) seem to use a pps_mutex and
> pps_event() seems to be using the pps_lock spinlock (because that
> gets executed from interrupt context) -- and from the looks of it, the
> register/unregister functions are using /both/ the mutex and spinlock (!)
This is right.
> This isn't quite right, (in fact there's nothing to protect pps_event from
> racing against a syscall), so you should use *only* the spinlock for
> synchronization -- the spin_lock_irqsave/restore() variants, in fact.
We can't use the spin_lock_irqsave/restore() variants since PPS
sources cannot manage IRQ enable/disable. For instance, the serial
source doesn't manage IRQs directly but just uses it to record PPS
events. The serial driver manages the IRQ enable/disable, not the PPS
source which only uses the IRQ handler to records events.
About using both mutex and spinlock I did it since (I think) I should
protect syscalls from each others and from pps_register/unregister(),
and pps_event() against pps_register/unregister().
> [ Also, have you considered making pps_source a list and not an array?
> It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
> kind of gymnastics in there, and you _can_ return a pointer to the
> corresponding pps source struct from the register() function to the in-kernel
> users, so that way you get to retain the O(1) access to the corresponding
> source when a client calls into pps_event(), similar to how you're using the
> array index presently. ]
>
> I also noticed code like (from pps_event):
>
> + /* Try to grab the lock, if not we prefere loose the event... */
> + if (!spin_trylock(&pps_lock))
> + return;
>
> which looks worrisome and unnecessary. That spinlock looks to be of
> fine enough granularity to me, do you think there'd be any contention
> on it? I /think/ you can simply make that a spin_lock().
This is due the fact I cannot manage IRQ enable/disable.
> Overall the code looks simple / straightforward enough to me (except for
> the parport / uart stuff that I have no clue about), and I'll also read up on
> the relevant RFC for this and would hopefully try and give you a more
> meaningful review over the weekend.
Thanks a lot for your help!
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 23:41 ` Satyam Sharma
@ 2007-07-29 9:50 ` Rodolfo Giometti
2007-07-30 5:03 ` Satyam Sharma
2007-07-29 9:57 ` Rodolfo Giometti
2007-07-29 10:00 ` Rodolfo Giometti
2 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-29 9:50 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote:
>
> Take the race between the time_pps_setparams() syscall and a concurrent
> pps_event() from an interrupt for instance. From sys_time_pps_setparams,
> the parameters for an existing source are not modified / set atomically,
> which means a pps_event() called on the same source in between will see
> invalid parameters ... and bad things will happen.
I are right. I'll add spinlocks. :)
> > [ Also, have you considered making pps_source a list and not an array?
> > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
> > kind of gymnastics in there, and you _can_ return a pointer to the
> > corresponding pps source struct from the register() function to the in-kernel
> > users, so that way you get to retain the O(1) access to the corresponding
> > source when a client calls into pps_event(), similar to how you're using the
> > array index presently. ]
>
> I think the above would be sane and safe -- your driver has pretty simple
> lifetime rules, and "sources" are only created / destroyed from within kernel,
> as and when clients call pps_register_source() and pps_unregister_source().
> So pps_event() can be called on a given source only between the
> corresponding register() and unregister() -- which means register() can
> return us a reference/pointer on the source after allocating / adding it to
> the list (instead of the fixed array index as it presently is), which remains
> valid for the entire duration of the source, till unregister() is called, after
> which we can't be calling pps_event() on the same source anyway.
Ok. I see. I'll study the problem but I think this is can be done
later, now I think is better having a working code. :)
> Ok, I've looked through (most of) the RFC and code now, and am only
> commenting on a design-level for now. Anyway, I didn't like the way
> you've significantly drifted from the RFC in several ways:
>
> 1. The RFC mandates no such userspace interface / syscall as the
> time_pps_cmd() that you've implemented -- it looks, smells, and feels
> like an ioctl, in fact that's what it is for practical purposes. I'm confused
> as to why didn't you just go ahead and implement the special-file-and-
> file-descriptor based approach as advocated / mandated there.
This is because is not always true that a PPS source is connected with
a char (or other) device. People whose designed RFC didn't think about
systems where the PPS signal is connected with a CPU's GPIO and the
O.S. doesn't provide any char device to refere with!
In the common desktop PCs the GPS antenna is connected with the serial
line and the PPS source is attached to the serial CD, but in the
embedded systems this is _not_ true. GPS antennae may still be
connected with serial line but the PPS signal is usually connected
with a GPIO pin.
In this scenario you cannot use the serial file descriptor to manage
the PPS signal since it cannot goes to the serial port.
> [ You've implemented the (optional, as per RFC) time_pps_findsource
> operation in the kernel using the above "pseudo-ioctl", but that wasn't
> necessary -- as the RFC itself illustrates, it's something that can easily
> be done (in fact should be done) completely in userspace itself. ]
I used pseudo-ioctl interface since it allows me to easily extend PPS
support with special, and uncommon, commands.
> 2. If you fix the above two issues, you'll notice that you don't need to
> short-circuit the (RFC-mandated) time_pps_create/destroy(handle)
> syscalls in the userspace header/library anymore, as you presently are.
This is just the reason why I added those functions. :)
> Here's how I'd go about desiging/implementing this:
>
> * At the time of pps_register_source() -- called by an in-kernel client
> subsystem that creates a PPS source -- allocate a pps source, generate
> an identifier for it, instantiate a special file -- the RFC does not mention
> whether a char or block device, but char device (I noticed an example
> in the RFC where they've used /dev/ppsXX as a possible path) would be
> proper for this. Finally add it to the list of sources. This returns a
> reference/pointer on that source back to the in-kernel client, which then
> passes *that* to pps_event(), similar to how you're presently using the
> array index.
If your GPS antenna is connected with a CPU's GPIO you have _no_
in-kernel client subsystem that creates a PPS source.
> [ The way you've passed the path of the parport/uart device itself
> (/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source()
> in pps_info.path doesn't quite look right to me. Note that the userspace is
> expected to open(2) the special file corresponding to the *PPS* source,
> as instantiated from the above code, and not the /dev/xyz special file of
> the *physical* port through which a pulse-generating device may be
> connected to the PC. ]
As above, if your GPS antenna is connected with a CPU's GPIO you have
_no_ device to open at all, that's why you need at least a function
like pps_findsource().
Note that in this case the pps_info.path is void. Please, see the
special client drivers/pps/clients/ktimer.c, it emulates the case
where you have no /dev/XXX to open(2). If your modifications resolve
the problems to manage the ktimer client you are going in the right
direction.
> * Userspace will open(2) the special file, and get an fd. Then calls the
> time_pps_create(fd, &handle) syscall -- kernel will find the pps source
> that matches that passed fd from the list of sources, and instantiates a
> "handle" associated with that source and returns that back to userspace.
Ditto.
> The rest would happen as usual / as you've currently implemented.
>
> I /think/ the RFC does envision such an implementation, so it helps us
> comply with that standard, and would also get rid of a lot of kludgy
> "findpath" and "findsource" stuff that we otherwise have to do in-kernel
> and userspace, as we're presently doing in the patch.
Unluckily the RFC does _not_ take into account PPS sources connected
with CPU's GPIO... in this case, in fact, you have _no_ char/block
device to open().
> [ BTW, it would be nice if you submit this stuff as a patchset that brings
> in functionality over a series of multiple patches -- the sysfs interface bits
> can be introduced in a different patch from the syscalls, which can be
> introduced in a different patch from the kernel-side API, etc ... that helps
> a code-level review. ]
Ok, I see, but I think this should be done when everithing is ok. I
think after fixing locking issue I can do it, can't I?
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 23:41 ` Satyam Sharma
2007-07-29 9:50 ` Rodolfo Giometti
@ 2007-07-29 9:57 ` Rodolfo Giometti
2007-07-29 10:00 ` Rodolfo Giometti
2 siblings, 0 replies; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-29 9:57 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote:
>
> Ok, I've looked through (most of) the RFC and code now, and am only
> commenting on a design-level for now. Anyway, I didn't like the way
> you've significantly drifted from the RFC in several ways:
Please, read documentation file Documentation/pps/pps.txt where I
exaplain why I did such RFC changes in my implementation.
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-27 23:41 ` Satyam Sharma
2007-07-29 9:50 ` Rodolfo Giometti
2007-07-29 9:57 ` Rodolfo Giometti
@ 2007-07-29 10:00 ` Rodolfo Giometti
2007-07-30 5:09 ` Satyam Sharma
2 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-29 10:00 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote:
> Take the race between the time_pps_setparams() syscall and a concurrent
> pps_event() from an interrupt for instance. From sys_time_pps_setparams,
> the parameters for an existing source are not modified / set atomically,
> which means a pps_event() called on the same source in between will see
> invalid parameters ... and bad things will happen.
I think this should be a good solution... :)
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
index 08de71d..f0c42ec 100644
--- a/drivers/pps/kapi.c
+++ b/drivers/pps/kapi.c
@@ -29,12 +29,6 @@
#include <linux/pps.h>
/*
- * Local variables
- */
-
-static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED;
-
-/*
* Local functions
*/
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
index 9176c01..91b7e4d 100644
--- a/drivers/pps/pps.c
+++ b/drivers/pps/pps.c
@@ -35,6 +35,7 @@
struct pps_s pps_source[PPS_MAX_SOURCES];
DEFINE_MUTEX(pps_mutex);
+spinlock_t pps_lock = SPIN_LOCK_UNLOCKED;
/*
* Misc functions
@@ -227,6 +228,8 @@ asmlinkage long sys_time_pps_setparams(int source,
goto sys_time_pps_setparams_exit;
}
+ spin_lock(&pps_lock);
+
/* Save the new parameters */
ret = copy_from_user(&pps_source[source].params, params,
sizeof(struct pps_kparams));
@@ -245,6 +248,8 @@ asmlinkage long sys_time_pps_setparams(int source,
pps_source[source].params.mode |= PPS_CANWAIT;
pps_source[source].params.api_version = PPS_API_VERS;
+ spin_unlock(&pps_lock);
+
sys_time_pps_setparams_exit:
mutex_unlock(&pps_mutex);
diff --git a/include/linux/pps.h b/include/linux/pps.h
index 6eca3ea..93e7384 100644
--- a/include/linux/pps.h
+++ b/include/linux/pps.h
@@ -174,6 +174,7 @@ struct pps_s {
extern struct pps_s pps_source[PPS_MAX_SOURCES];
extern struct mutex pps_mutex;
+extern spinlock_t pps_lock;
/*
* Global functions
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-29 9:17 ` Rodolfo Giometti
@ 2007-07-30 4:19 ` Satyam Sharma
2007-07-30 8:32 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 4:19 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
Hi Rodolfo,
On Sun, 29 Jul 2007, Rodolfo Giometti wrote:
> On Sat, Jul 28, 2007 at 02:17:24AM +0530, Satyam Sharma wrote:
> >
> > I only glanced through the code, so could be wrong, but I noticed that
> > the only global / shared data you have in there is a global "pps_source"
> > array of pps_s structs. That's accessed / modified from the various
> > syscalls introduced in the API exported to userspace, as well as the
> > register/unregister/pps_event API exported to in-kernel client subsystems,
> > yes? So it looks like you need to introduce proper locking for it, simply
> > type-qualifying it as "volatile" is not enough.
> >
> > However, I think you've introduced two locks for it. The syscalls (that
> > run in process context, obviously) seem to use a pps_mutex and
> > pps_event() seems to be using the pps_lock spinlock (because that
> > gets executed from interrupt context) -- and from the looks of it, the
> > register/unregister functions are using /both/ the mutex and spinlock (!)
>
> This is right.
>
> > This isn't quite right, (in fact there's nothing to protect pps_event from
> > racing against a syscall), so you should use *only* the spinlock for
> > synchronization -- the spin_lock_irqsave/restore() variants, in fact.
>
> We can't use the spin_lock_irqsave/restore() variants since PPS
> sources cannot manage IRQ enable/disable. For instance, the serial
> source doesn't manage IRQs directly but just uses it to record PPS
> events. The serial driver manages the IRQ enable/disable, not the PPS
> source which only uses the IRQ handler to records events.
Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore()
in pps_event() around the access to pps_source.
> About using both mutex and spinlock I did it since (I think) I should
> protect syscalls from each others and from pps_register/unregister(),
> and pps_event() against pps_register/unregister().
Nopes, it's not about protecting code from each other, you're needlessly
complicating things. Locking is pretty simple, really -- any shared data,
that can be concurrently accessed by multiple threads (or from interrupts)
must be protected with a lock. Note that *data* is protected by a lock,
and not "code" that handles it (well, this is the kind of behaviour most
cases need, at least, including yours).
So here we're introducing the lock to protect *pps_source*, and not keep
*threads* of execution from stepping over each other. So, simply, just
ensure you grab the lock whenever you want to start accessing the shared
data, and release it when you're done.
The _irqsave/restore() variants are required because (say) one of the
syscalls executing in process context grabs the spinlock. Then, before it
has released it, it gets interrupted and pps_event() begins executing.
Now pps_event() also wants to grab the lock, but the syscall already
has it, so will continue spinning and deadlock!
> > [ Also, have you considered making pps_source a list and not an array?
> > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
> > kind of gymnastics in there, and you _can_ return a pointer to the
> > corresponding pps source struct from the register() function to the in-kernel
> > users, so that way you get to retain the O(1) access to the corresponding
> > source when a client calls into pps_event(), similar to how you're using the
> > array index presently. ]
> >
> > I also noticed code like (from pps_event):
> >
> > + /* Try to grab the lock, if not we prefere loose the event... */
> > + if (!spin_trylock(&pps_lock))
> > + return;
> >
> > which looks worrisome and unnecessary. That spinlock looks to be of
> > fine enough granularity to me, do you think there'd be any contention
> > on it? I /think/ you can simply make that a spin_lock().
>
> This is due the fact I cannot manage IRQ enable/disable.
What I meant is that you could make it a proper spin_lock() --
or spin_lock_irqsave(), actually -- instead of the _trylock_ variant
that it currently is.
I think you're unnecessarily worrying about contention here -- you can
have multiple locks (one for the list, and separate ones for your sources)
if you're really worrying about contention -- or probably rwlocks. But
really, rwlocks would end up being *slower* than spinlocks, unless the
contention is really heavy and it helps to keep multiple readers in the
critical section. But frankly, with at max a few (I'd expect generally
one) PPS sources ever to be connected / registered with teh system, and
just one-pulse-per-second, I don't see why any contention is ever gonna
happen.
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-29 9:50 ` Rodolfo Giometti
@ 2007-07-30 5:03 ` Satyam Sharma
2007-07-30 8:51 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 5:03 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
Hi,
On Sun, 29 Jul 2007, Rodolfo Giometti wrote:
> On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote:
>
> > > [ Also, have you considered making pps_source a list and not an array?
> > > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc
> > > kind of gymnastics in there, and you _can_ return a pointer to the
> > > corresponding pps source struct from the register() function to the in-kernel
> > > users, so that way you get to retain the O(1) access to the corresponding
> > > source when a client calls into pps_event(), similar to how you're using the
> > > array index presently. ]
> >
> > I think the above would be sane and safe -- your driver has pretty simple
> > lifetime rules, and "sources" are only created / destroyed from within kernel,
> > as and when clients call pps_register_source() and pps_unregister_source().
> > So pps_event() can be called on a given source only between the
> > corresponding register() and unregister() -- which means register() can
> > return us a reference/pointer on the source after allocating / adding it to
> > the list (instead of the fixed array index as it presently is), which remains
> > valid for the entire duration of the source, till unregister() is called, after
> > which we can't be calling pps_event() on the same source anyway.
>
> Ok. I see. I'll study the problem but I think this is can be done
> later, now I think is better having a working code. :)
Fair enough, but I think the code could become a trifle simpler/easier
after the conversion, so probably greater chances of getting merged :-)
> > Ok, I've looked through (most of) the RFC and code now, and am only
> > commenting on a design-level for now. Anyway, I didn't like the way
> > you've significantly drifted from the RFC in several ways:
> >
> > 1. The RFC mandates no such userspace interface / syscall as the
> > time_pps_cmd() that you've implemented -- it looks, smells, and feels
> > like an ioctl, in fact that's what it is for practical purposes. I'm confused
> > as to why didn't you just go ahead and implement the special-file-and-
> > file-descriptor based approach as advocated / mandated there.
>
> This is because is not always true that a PPS source is connected with
> a char (or other) device.
But that's alright -- see, as I said, you're confusing between the
"special device" that represents the *PPS source* itself, with the port
or device that it uses to *physically* connect to the PC.
In the RFC, when they say that the userspace app must open(2) the PPS
source (as they have illustrated in the example too), they mean that
it open(2)'s the special device/file associated with the PPS source,
and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected
through physically.
So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course,
no such special device exists on a Linux box already, but that's fine
and obvious! *You* are supposed to create / instantiate that when a
pps_register_source() is done from some in-kernel subsystem.
> People whose designed RFC didn't think about
> systems where the PPS signal is connected with a CPU's GPIO and the
> O.S. doesn't provide any char device to refere with!
As I said, it's not the char device for the physical interface itself
being discussed there. That could be parport, uart, some arbit GPIO pin
whatever. But whenever the corresponding kernel subsystem does a
register_source(), you could create the /dev/ppsXXX device ...
> In the common desktop PCs the GPS antenna is connected with the serial
> line and the PPS source is attached to the serial CD, but in the
> embedded systems this is _not_ true. GPS antennae may still be
> connected with serial line but the PPS signal is usually connected
> with a GPIO pin.
>
> In this scenario you cannot use the serial file descriptor to manage
> the PPS signal since it cannot goes to the serial port.
See above.
> > [ You've implemented the (optional, as per RFC) time_pps_findsource
> > operation in the kernel using the above "pseudo-ioctl", but that wasn't
> > necessary -- as the RFC itself illustrates, it's something that can easily
> > be done (in fact should be done) completely in userspace itself. ]
>
> I used pseudo-ioctl interface since it allows me to easily extend PPS
> support with special, and uncommon, commands.
Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see
how you can get this merged, really :-)
> > * At the time of pps_register_source() -- called by an in-kernel client
> > subsystem that creates a PPS source -- allocate a pps source, generate
> > an identifier for it, instantiate a special file -- the RFC does not mention
> > whether a char or block device, but char device (I noticed an example
> > in the RFC where they've used /dev/ppsXX as a possible path) would be
> > proper for this. Finally add it to the list of sources. This returns a
> > reference/pointer on that source back to the in-kernel client, which then
> > passes *that* to pps_event(), similar to how you're presently using the
> > array index.
>
> If your GPS antenna is connected with a CPU's GPIO you have _no_
> in-kernel client subsystem that creates a PPS source.
See above.
> > [ The way you've passed the path of the parport/uart device itself
> > (/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source()
> > in pps_info.path doesn't quite look right to me. Note that the userspace is
> > expected to open(2) the special file corresponding to the *PPS* source,
> > as instantiated from the above code, and not the /dev/xyz special file of
> > the *physical* port through which a pulse-generating device may be
> > connected to the PC. ]
>
> As above, if your GPS antenna is connected with a CPU's GPIO you have
> _no_ device to open at all, that's why you need at least a function
> like pps_findsource().
>
> Note that in this case the pps_info.path is void. Please, see the
> special client drivers/pps/clients/ktimer.c, it emulates the case
> where you have no /dev/XXX to open(2). If your modifications resolve
> the problems to manage the ktimer client you are going in the right
> direction.
Again, see above.
> > I /think/ the RFC does envision such an implementation, so it helps us
> > comply with that standard, and would also get rid of a lot of kludgy
> > "findpath" and "findsource" stuff that we otherwise have to do in-kernel
> > and userspace, as we're presently doing in the patch.
>
> Unluckily the RFC does _not_ take into account PPS sources connected
> with CPU's GPIO... in this case, in fact, you have _no_ char/block
> device to open().
And again, see above.
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-29 10:00 ` Rodolfo Giometti
@ 2007-07-30 5:09 ` Satyam Sharma
2007-07-30 8:53 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 5:09 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
Hi Rodolfo,
On Sun, 29 Jul 2007, Rodolfo Giometti wrote:
> On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote:
>
> > Take the race between the time_pps_setparams() syscall and a concurrent
> > pps_event() from an interrupt for instance. From sys_time_pps_setparams,
> > the parameters for an existing source are not modified / set atomically,
> > which means a pps_event() called on the same source in between will see
> > invalid parameters ... and bad things will happen.
>
> I think this should be a good solution... :)
>
> diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
> index 08de71d..f0c42ec 100644
> --- a/drivers/pps/kapi.c
> +++ b/drivers/pps/kapi.c
> @@ -29,12 +29,6 @@
> #include <linux/pps.h>
>
> /*
> - * Local variables
> - */
> -
> -static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED;
> -
> -/*
> * Local functions
> */
>
> diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
> index 9176c01..91b7e4d 100644
> --- a/drivers/pps/pps.c
> +++ b/drivers/pps/pps.c
> @@ -35,6 +35,7 @@
>
> struct pps_s pps_source[PPS_MAX_SOURCES];
> DEFINE_MUTEX(pps_mutex);
> +spinlock_t pps_lock = SPIN_LOCK_UNLOCKED;
>
> /*
> * Misc functions
> @@ -227,6 +228,8 @@ asmlinkage long sys_time_pps_setparams(int source,
> goto sys_time_pps_setparams_exit;
> }
>
> + spin_lock(&pps_lock);
> +
> /* Save the new parameters */
> ret = copy_from_user(&pps_source[source].params, params,
> sizeof(struct pps_kparams));
> @@ -245,6 +248,8 @@ asmlinkage long sys_time_pps_setparams(int source,
> pps_source[source].params.mode |= PPS_CANWAIT;
> pps_source[source].params.api_version = PPS_API_VERS;
>
> + spin_unlock(&pps_lock);
> +
> sys_time_pps_setparams_exit:
> mutex_unlock(&pps_mutex);
Nopes, this isn't quite correct/safe. I suggest you should read:
http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 4:19 ` Satyam Sharma
@ 2007-07-30 8:32 ` Rodolfo Giometti
2007-07-30 9:07 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-30 8:32 UTC (permalink / raw)
To: Satyam Sharma
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
On Mon, Jul 30, 2007 at 09:49:20AM +0530, Satyam Sharma wrote:
>
> Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore()
> in pps_event() around the access to pps_source.
In pps_event() is not useful using spin_lock_irqsave/restore() since
the only difference between spin_lock_irqsave() and spin_lock() is
that the former will turn off interrupts if they are on, otherwise
does nothing (if we are already in an interrupt handler).
Maybe you meant I should using spin_lock_irqsave/restore() in user
context, but doing like this I will disable interrupts and I don't
wish doing it since, in this manner, the interrupt handler will be
delayed and the (probably) PPS event recording will be wrong. I
prefere loosing the event that registering it at delayed time.
> > About using both mutex and spinlock I did it since (I think) I should
> > protect syscalls from each others and from pps_register/unregister(),
> > and pps_event() against pps_register/unregister().
>
> Nopes, it's not about protecting code from each other, you're needlessly
> complicating things. Locking is pretty simple, really -- any shared data,
> that can be concurrently accessed by multiple threads (or from interrupts)
> must be protected with a lock. Note that *data* is protected by a lock,
> and not "code" that handles it (well, this is the kind of behaviour most
> cases need, at least, including yours).
Of course, I meant "protecting data". In fact to protect pps_source[]
I need spin_lock() to protect user context from interrupt context and
mutex to protect user context from itself.
> So here we're introducing the lock to protect *pps_source*, and not keep
> *threads* of execution from stepping over each other. So, simply, just
> ensure you grab the lock whenever you want to start accessing the shared
> data, and release it when you're done.
I see. But consider pps_register_source(). This function should
provide protection of pps_source against both interrupt context
(pps_event()) and user context (maybe pps_unregister_source() or one
syscalls). Using only mutex is not possible, since we cannot use mutex
in interrupt context, and using only spin_locks is not possible since
in UP() they became void.
Can you please show me how I could write pps_register_source() in
order to be correct from your point of view?
> The _irqsave/restore() variants are required because (say) one of the
> syscalls executing in process context grabs the spinlock. Then, before it
> has released it, it gets interrupted and pps_event() begins executing.
> Now pps_event() also wants to grab the lock, but the syscall already
> has it, so will continue spinning and deadlock!
That's the point. I don't wish using _irqsave/restore() since they may
delay interrupt handler execution. As above, I prefere loosing the
event then registering it at wrong time.
> I think you're unnecessarily worrying about contention here -- you can
> have multiple locks (one for the list, and separate ones for your sources)
> if you're really worrying about contention -- or probably rwlocks. But
> really, rwlocks would end up being *slower* than spinlocks, unless the
> contention is really heavy and it helps to keep multiple readers in the
> critical section. But frankly, with at max a few (I'd expect generally
> one) PPS sources ever to be connected / registered with teh system, and
> just one-pulse-per-second, I don't see why any contention is ever gonna
> happen.
Why you wish using one lock per sources? Just one lock for the
list/array is not enought? :-o
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 5:03 ` Satyam Sharma
@ 2007-07-30 8:51 ` Rodolfo Giometti
2007-07-30 9:20 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-30 8:51 UTC (permalink / raw)
To: Satyam Sharma
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote:
>
> Fair enough, but I think the code could become a trifle simpler/easier
> after the conversion, so probably greater chances of getting merged :-)
I see. I'll start thinging about it.
> But that's alright -- see, as I said, you're confusing between the
> "special device" that represents the *PPS source* itself, with the port
> or device that it uses to *physically* connect to the PC.
>
> In the RFC, when they say that the userspace app must open(2) the PPS
> source (as they have illustrated in the example too), they mean that
> it open(2)'s the special device/file associated with the PPS source,
> and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected
> through physically.
>
> So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course,
> no such special device exists on a Linux box already, but that's fine
> and obvious! *You* are supposed to create / instantiate that when a
> pps_register_source() is done from some in-kernel subsystem.
So your are proposing to create a char device interface then using
syscalls one? In this case how do you manage the case where your GPS
antenna and PPS source are both connected with the serial port
(i.e. /dev/ttyS0)?
Currently the RFC says to you that you should open the serial port:
fd = open("/dev/ttyS0", ...);
and the passing its filedes to pps_time_create() in order to get the
corresponding PPS source handler:
pps_time_create(fd, &handler);
As you propose you need _two_ open() and not just one... and even if
you decide to open the /dev/ppsX inside the pps_time_create(), how do
you recognise _which_ /dev/ppsX is connected with filedse "fd"?
I quite sure that RFC is broken since it doesn't take in account that
a PPS source maybe not connected with any cahr device at all. I tried
to explain this problem to RFC's gurus but they never answered to me,
so I decided to resolve the problem by myself. ;)
> As I said, it's not the char device for the physical interface itself
> being discussed there. That could be parport, uart, some arbit GPIO pin
> whatever. But whenever the corresponding kernel subsystem does a
> register_source(), you could create the /dev/ppsXXX device ...
Ok, but in this case you still are _not_ RFC compliant (as showed
above). You need that users give to you _two_ devices (the serial line
and the PPS source), meanwhile, for the RFC, you just need one. So no
differences from my solution from this point of view.
> Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see
> how you can get this merged, really :-)
They are not-mandated-by-RFC since simply RFC _is broken_! :)
I need them (or just one of them) in order to find a PPS source into
the system. Just as you need the second device name in your solution
with char devices.
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 5:09 ` Satyam Sharma
@ 2007-07-30 8:53 ` Rodolfo Giometti
2007-07-30 9:31 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-30 8:53 UTC (permalink / raw)
To: Satyam Sharma
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
On Mon, Jul 30, 2007 at 10:39:38AM +0530, Satyam Sharma wrote:
>
> Nopes, this isn't quite correct/safe. I suggest you should read:
>
> http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/
I read it but still I don't see why my solution isn't correct/safe. :)
Can you please propose to me your solution?
Thanks a lot for you time!
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 8:32 ` Rodolfo Giometti
@ 2007-07-30 9:07 ` Satyam Sharma
2007-07-30 14:55 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 9:07 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi,
On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> On Mon, Jul 30, 2007 at 09:49:20AM +0530, Satyam Sharma wrote:
> >
> > Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore()
> > in pps_event() around the access to pps_source.
>
> In pps_event() is not useful using spin_lock_irqsave/restore() since
> the only difference between spin_lock_irqsave() and spin_lock() is
> that the former will turn off interrupts if they are on, otherwise
> does nothing (if we are already in an interrupt handler).
Yup. But two pps_event()'s on different CPU's could still race.
> Maybe you meant I should using spin_lock_irqsave/restore() in user
> context, but doing like this I will disable interrupts
Yup, but the goal is to avoid races. Otherwise why bother doing any
locking at all?
> and I don't
> wish doing it since, in this manner, the interrupt handler will be
> delayed and the (probably) PPS event recording will be wrong. I
> prefere loosing the event that registering it at delayed time.
What you're risking is not "losing an event" (which, btw, you should
not be, either), but a *deadlock*.
> > > About using both mutex and spinlock I did it since (I think) I should
> > > protect syscalls from each others and from pps_register/unregister(),
> > > and pps_event() against pps_register/unregister().
> >
> > Nopes, it's not about protecting code from each other, you're needlessly
> > complicating things. Locking is pretty simple, really -- any shared data,
> > that can be concurrently accessed by multiple threads (or from interrupts)
> > must be protected with a lock. Note that *data* is protected by a lock,
> > and not "code" that handles it (well, this is the kind of behaviour most
> > cases need, at least, including yours).
>
> Of course, I meant "protecting data". In fact to protect pps_source[]
> I need spin_lock() to protect user context from interrupt context and
> mutex to protect user context from itself.
But that's nonsensical! That's not how you implement locking!
First, spin_lock() is *not* enough to protect access from process context
from access from interrupt context.
Second, if you *already* have a lock to protect any data, introducing
*another* lock to protect the same data is ... utterly crazy!
> > So here we're introducing the lock to protect *pps_source*, and not keep
> > *threads* of execution from stepping over each other. So, simply, just
> > ensure you grab the lock whenever you want to start accessing the shared
> > data, and release it when you're done.
>
> I see. But consider pps_register_source(). This function should
> provide protection of pps_source against both interrupt context
> (pps_event()) and user context (maybe pps_unregister_source() or one
> syscalls). Using only mutex is not possible, since we cannot use mutex
> in interrupt context, and using only spin_locks is not possible since
> in UP() they became void.
Yup, but that's okay. On UP, spin_lock_irqsave() becomes local_irq_save()
which is what you want anyway on UP.
> Can you please show me how I could write pps_register_source() in
> order to be correct from your point of view?
The simplest, most straightforward, and safest, most correct, way would
be to just use spin_lock_irqsave/restore() to around all access to the
shared/global data, from _any_ context.
Anyway, I'll try and see if I find some time this week to implement
what I was mentioning ...
> > The _irqsave/restore() variants are required because (say) one of the
> > syscalls executing in process context grabs the spinlock. Then, before it
> > has released it, it gets interrupted and pps_event() begins executing.
> > Now pps_event() also wants to grab the lock, but the syscall already
> > has it, so will continue spinning and deadlock!
>
> That's the point. I don't wish using _irqsave/restore() since they may
> delay interrupt handler execution. As above, I prefere loosing the
> event then registering it at wrong time.
Ok, think of it this way -- you don't have an option. You just *have*
to use them. As I said, please read Rusty Russell's introduction to
locking in the kernel.
> > I think you're unnecessarily worrying about contention here -- you can
> > have multiple locks (one for the list, and separate ones for your sources)
> > if you're really worrying about contention -- or probably rwlocks. But
> > really, rwlocks would end up being *slower* than spinlocks, unless the
> > contention is really heavy and it helps to keep multiple readers in the
> > critical section. But frankly, with at max a few (I'd expect generally
> > one) PPS sources ever to be connected / registered with teh system, and
> > just one-pulse-per-second, I don't see why any contention is ever gonna
> > happen.
>
> Why you wish using one lock per sources? Just one lock for the
> list/array is not enought? :-o
No, I am *not* wishing / advocating that at all. Just that you appear so
_reluctant_ to use spinlocks and are unnecessarily worrying about
contention, disabling interrupts, etc etc.
Just use the spin_lock_irqsave/restore() variants, and you'll be fine.
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 8:51 ` Rodolfo Giometti
@ 2007-07-30 9:20 ` Satyam Sharma
2007-08-01 22:14 ` Christopher Hoover
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 9:20 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel,
Andrew Morton
On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote:
> >
> > Fair enough, but I think the code could become a trifle simpler/easier
> > after the conversion, so probably greater chances of getting merged :-)
>
> I see. I'll start thinging about it.
>
> > But that's alright -- see, as I said, you're confusing between the
> > "special device" that represents the *PPS source* itself, with the port
> > or device that it uses to *physically* connect to the PC.
> >
> > In the RFC, when they say that the userspace app must open(2) the PPS
> > source (as they have illustrated in the example too), they mean that
> > it open(2)'s the special device/file associated with the PPS source,
> > and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected
> > through physically.
> >
> > So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course,
> > no such special device exists on a Linux box already, but that's fine
> > and obvious! *You* are supposed to create / instantiate that when a
> > pps_register_source() is done from some in-kernel subsystem.
>
> So your are proposing to create a char device interface then using
> syscalls one? In this case how do you manage the case where your GPS
> antenna and PPS source are both connected with the serial port
> (i.e. /dev/ttyS0)?
That's *precisely* what I just explained above!
You create that special device at the time of pps_register_source()!
> Currently the RFC says to you that you should open the serial port:
>
> fd = open("/dev/ttyS0", ...);
No, it does *NOT*. All it says is:
The time_pps_create() is used to convert an already-open UNIX file
descriptor, for an appropriate special file, into a PPS handle.
See? What I said is precisely the implementation the RFC envisages
(and the only sane way to implement it too).
And later, where it gives an example, it shows:
fd = open(PPSfilename, O_RDWR, 0);
What I'm saying is that the "PPSfilename", as is obvious from the name
itself, is *not* a port such as lpXXX or ttySXXX, but an "appropriate
special file" corresponding to a ... PPS source! Really, the RFC is
quite clear and easy to read, I have no idea how to explain that more
clearly ...
> and the passing its filedes to pps_time_create() in order to get the
> corresponding PPS source handler:
>
> pps_time_create(fd, &handler);
Yes.
> As you propose you need _two_ open() and not just one...
No, why?
> and even if
> you decide to open the /dev/ppsX inside the pps_time_create(), how do
> you recognise _which_ /dev/ppsX is connected with filedse "fd"?
That's trivial to implement in the kernel code for the time_pps_create()
syscall.
> I quite sure that RFC is broken since it doesn't take in account that
> a PPS source maybe not connected with any cahr device at all. I tried
> to explain this problem to RFC's gurus but they never answered to me,
> so I decided to resolve the problem by myself. ;)
Nopes, the RFC is not broken at all. All this physical-connection-port
device vs PPS-source-device confusion is just in your mind :-)
> > As I said, it's not the char device for the physical interface itself
> > being discussed there. That could be parport, uart, some arbit GPIO pin
> > whatever. But whenever the corresponding kernel subsystem does a
> > register_source(), you could create the /dev/ppsXXX device ...
>
> Ok, but in this case you still are _not_ RFC compliant (as showed
> above). You need that users give to you _two_ devices (the serial line
> and the PPS source), meanwhile, for the RFC, you just need one. So no
> differences from my solution from this point of view.
Yeah, so how am I not RFC compliant? Userspace will *only* open(2) the
special char device of the *PPS source*, and have *nothing* to do with
the device corresponding to the physical device/port it is connected
through!
> > Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see
> > how you can get this merged, really :-)
>
> They are not-mandated-by-RFC since simply RFC _is broken_! :)
It is not ...
> I need them (or just one of them) in order to find a PPS source into
> the system. Just as you need the second device name in your solution
> with char devices.
No, I don't need any "second device". I *only* need the "appropriate
special file" as mentioned in the RFC. I don't give a *damn* for
what *physical device/port* the source is actually connected through.
I suggest you should read the RFC again ...
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 8:53 ` Rodolfo Giometti
@ 2007-07-30 9:31 ` Satyam Sharma
0 siblings, 0 replies; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 9:31 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi Rodolfo,
On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> On Mon, Jul 30, 2007 at 10:39:38AM +0530, Satyam Sharma wrote:
> >
> > Nopes, this isn't quite correct/safe. I suggest you should read:
> >
> > http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/
>
> I read it but still I don't see why my solution isn't correct/safe. :)
What does the section on locking between hard irq contexts (or between
user process context and hard irq context) say?
> Can you please propose to me your solution?
As I said, you could just use the spin_lock_irqsave/restore() variants ...
If you want, I can try and implement the other bits that I had suggested
for the other things as well :-)
Ciao,
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 9:07 ` Satyam Sharma
@ 2007-07-30 14:55 ` Rodolfo Giometti
2007-07-30 22:01 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-30 14:55 UTC (permalink / raw)
To: Satyam Sharma
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton,
Satyam Sharma
On Mon, Jul 30, 2007 at 02:37:26PM +0530, Satyam Sharma wrote:
> On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> >
> > In pps_event() is not useful using spin_lock_irqsave/restore() since
> > the only difference between spin_lock_irqsave() and spin_lock() is
> > that the former will turn off interrupts if they are on, otherwise
> > does nothing (if we are already in an interrupt handler).
>
> Yup. But two pps_event()'s on different CPU's could still race.
??? :-o
Maybe one CPU spins 'till the other holds the lock but any races
should happen...
> > Maybe you meant I should using spin_lock_irqsave/restore() in user
> > context, but doing like this I will disable interrupts
>
> Yup, but the goal is to avoid races. Otherwise why bother doing any
> locking at all?
I meant that if you have to lock between user context and interrupt
context you have two choises:
1) using spin_lock_irqsave/restore() in user context and spin_lock/unlock()
in the interrupt context (as Rusty says),
2) or using spin_lock/unlock() in user context and
spin_trylock/unlock() in the interrupt context in order to avoid dead
locks.
Is that correct?
> > Of course, I meant "protecting data". In fact to protect pps_source[]
> > I need spin_lock() to protect user context from interrupt context and
> > mutex to protect user context from itself.
>
> But that's nonsensical! That's not how you implement locking!
>
> First, spin_lock() is *not* enough to protect access from process context
> from access from interrupt context.
>
> Second, if you *already* have a lock to protect any data, introducing
> *another* lock to protect the same data is ... utterly crazy!
I see what you mean. But my question is about using spin_locks where
we can sleep. Let me explain, consider sys_time_pps_getparams():
asmlinkage long sys_time_pps_getparams(int source,
struct pps_kparams __user *params)
{
int ret = 0;
pr_debug("%s: source %d\n", __FUNCTION__, source);
/* Sanity checks */
if (!params)
return -EINVAL;
if (mutex_lock_interruptible(&pps_mutex))
return -EINTR;
ret = pps_check_source(source);
if (ret < 0) {
ret = -ENODEV;
goto sys_time_pps_getparams_exit;
}
/* Return current parameters */
ret = copy_to_user(params, &pps_source[source].params,
sizeof(struct pps_kparams));
if (ret)
ret = -EFAULT;
sys_time_pps_getparams_exit:
mutex_unlock(&pps_mutex);
return ret;
}
The copy_to_user() may sleep and if I change
mutex_lock_interruptible() with a spin_lock I may hold it and then
going to sleep... using mutex we can use the CPU for other
computations.
> > I see. But consider pps_register_source(). This function should
> > provide protection of pps_source against both interrupt context
> > (pps_event()) and user context (maybe pps_unregister_source() or one
> > syscalls). Using only mutex is not possible, since we cannot use mutex
> > in interrupt context, and using only spin_locks is not possible since
> > in UP() they became void.
>
> Yup, but that's okay. On UP, spin_lock_irqsave() becomes local_irq_save()
> which is what you want anyway on UP.
But doing like this may happen that I first execute local_irq_save()
and then go to sleep due copy_to_user()? :-o
> The simplest, most straightforward, and safest, most correct, way would
> be to just use spin_lock_irqsave/restore() to around all access to the
> shared/global data, from _any_ context.
Even if I may sleep while holding a spinlock? Rusty says here
(http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/c557.html)
that:
Many functions in the kernel sleep (ie. call schedule()) directly
or indirectly: you can never call them while __holding a
spinlock__, or with preemption disabled. This also means you need
to be in user context: calling them from an interrupt is illegal.
> Anyway, I'll try and see if I find some time this week to implement
> what I was mentioning ...
Thanks a lot, so we can discuss on code. :)
> > That's the point. I don't wish using _irqsave/restore() since they may
> > delay interrupt handler execution. As above, I prefere loosing the
> > event then registering it at wrong time.
>
> Ok, think of it this way -- you don't have an option. You just *have*
> to use them. As I said, please read Rusty Russell's introduction to
> locking in the kernel.
I see but I don't see why using spin_lock/unlock() in user contex and
spin_trylock/unlock() in interrupt context is wrong. :)
> > Why you wish using one lock per sources? Just one lock for the
> > list/array is not enought? :-o
>
> No, I am *not* wishing / advocating that at all. Just that you appear so
> _reluctant_ to use spinlocks and are unnecessarily worrying about
> contention, disabling interrupts, etc etc.
>
> Just use the spin_lock_irqsave/restore() variants, and you'll be fine.
What I wish is just to avoid disabling IRQs in user context in order
to minimize the possibility to delay events recording. We this
requirement the only solution I see is using spin_trylock/unlock() in
interrupt context.
Another requirement is __not__ going to sleep while holding a spinlock
(as Rusty says) and again the only solution I see is using mutex.
Looking at my previous patch I found that it should be written like
this:
@@ -199,6 +200,7 @@ asmlinkage long sys_time_pps_setparams(int source,
const struct pps_kparams __user *params) {
int ret;
+ struct pps_kparams temp;
pr_debug(``%s: source %d\n'', __FUNCTION__, source);
@@ -228,13 +230,16 @@ asmlinkage long sys_time_pps_setparams(int source,
}
/* Save the new parameters */
- ret = copy_from_user(&pps_source[source].params, params,
- sizeof(struct pps_kparams));
+ ret = copy_from_user(&temp, params, sizeof(struct pps_kparams));
if (ret) {
ret = -EFAULT;
goto sys_time_pps_setparams_exit;
}
+ spin_lock(&pps_lock);
+
+ pps_source[source].params = temp;
+
/* Restore the read only parameters */
if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
/* section 3.3 of RFC 2783 interpreted */
@@ -245,6 +250,8 @@ asmlinkage long sys_time_pps_setparams(int source,
pps_source[source].params.mode |= PPS_CANWAIT;
pps_source[source].params.api_version = PPS_API_VERS;
+ spin_unlock(&pps_lock);
+
sys_time_pps_setparams_exit:
mutex_unlock(&pps_mutex);
In this manner I can going to sleep in copy_from_user() whitout
holding any locks.
On Mon, Jul 30, 2007 at 02:50:56PM +0530, Satyam Sharma wrote:
>
> No, it does *NOT*. All it says is:
>
> The time_pps_create() is used to convert an already-open UNIX file
> descriptor, for an appropriate special file, into a PPS handle.
>
> See? What I said is precisely the implementation the RFC envisages
> (and the only sane way to implement it too).
>
> And later, where it gives an example, it shows:
>
> fd = open(PPSfilename, O_RDWR, 0);
>
> What I'm saying is that the "PPSfilename", as is obvious from the name
> itself, is *not* a port such as lpXXX or ttySXXX, but an "appropriate
> special file" corresponding to a ... PPS source! Really, the RFC is
> quite clear and easy to read, I have no idea how to explain that more
> clearly ...
Ok, I see, but how you can get your PPS source data struct starting
from a file descriptor? :-o
> > As you propose you need _two_ open() and not just one...
>
> No, why?
Please, take alook at NTPD code. Common usage is:
fd = open("/dev/ttyS0", ...);
pps_time_create(fd, &handler);
since RFC supposes that at filedes "fd" is mapped both GPS data _and_
PPS source.
With your suggestion code should be changed as follow:
fd_gps = open("/dev/ttyS0", ...);
fd_pps = open("/dev/pps0", ...);
pps_time_create(fd_pps, &handler);
> > and even if
> > you decide to open the /dev/ppsX inside the pps_time_create(), how do
> > you recognise _which_ /dev/ppsX is connected with filedse "fd"?
>
> That's trivial to implement in the kernel code for the time_pps_create()
> syscall.
I didn't find a good solution for it.
Furthermore with my pps_findpath() I can do:
fd = open("/dev/ttyS0", ...);
handler = pps_findpath("/dev/ttyS0", ...);
which in most cases its more easy to manage for both user and kernel
land.
Can do the same with char devices? Maybe you can easily create
/dev/pps0 but how can you relate it with the /dev/ttyS0 if your GPS
antenna and PPS source share the same serial port?
I studied the problem trying to find a good solution for both NTPD
code (tring to change it as less as possible) and PPS sources
connected with CPU's GPIOs, but currently I find nothing better that
this.
> > I quite sure that RFC is broken since it doesn't take in account that
> > a PPS source maybe not connected with any cahr device at all. I tried
> > to explain this problem to RFC's gurus but they never answered to me,
> > so I decided to resolve the problem by myself. ;)
>
> Nopes, the RFC is not broken at all. All this physical-connection-port
> device vs PPS-source-device confusion is just in your mind :-)
Ok, if you don't think so try looking at NTPD code (written by RFC's
gurus) and try to resolve the problem where both GPS antenna and PPS
source are connected with a serial port, and the problem where only
the GPS antenna is connected with the serial port but the PPS source
is connected with a CPU's GPIO.
If you solve both them all PPS users will thank you a lot forever! :)
> > Ok, but in this case you still are _not_ RFC compliant (as showed
> > above). You need that users give to you _two_ devices (the serial line
> > and the PPS source), meanwhile, for the RFC, you just need one. So no
> > differences from my solution from this point of view.
>
> Yeah, so how am I not RFC compliant? Userspace will *only* open(2) the
> special char device of the *PPS source*, and have *nothing* to do with
> the device corresponding to the physical device/port it is connected
> through!
Ok, in your sceraio no problem, but continue to read RFC:
All of the other functions in the PPS API operate on PPS handles
(type: pps_handle_t). The time_pps_create() is used to convert an
already-open UNIX file descriptor, for an appropriate special file,
into a PPS handle.
The definition of what special files are appropriate for use with the
PPS API is outside the scope of this specification, and may vary
based on both operating system implementation, and local system
configuration. One typical case is a serial line, whose DCD pin is
connected to a source of PPS events.
This shows that RFC creators though only at PPS sources connected with
an _already_ opened device (as serial ports or parallel one), if not
why don't define the function time_pps_create() as:
int time_pps_create(char *ppsdev, pps_handle_t *handle);
???
No, they require an _already_ opened file descriptor because they
supposed you can use serial line file descriptor! So, if this is not
your case (because your PPS source is connected with a CPU's GPIO) you
_must_ use a second open() (not considere at all into NTPD code) or,
as I did, use a special function like pps_findsource/path().
> > I need them (or just one of them) in order to find a PPS source into
> > the system. Just as you need the second device name in your solution
> > with char devices.
>
> No, I don't need any "second device". I *only* need the "appropriate
> special file" as mentioned in the RFC. I don't give a *damn* for
> what *physical device/port* the source is actually connected through.
> I suggest you should read the RFC again ...
I read it. Ok, according your solution and not considering the two
open()s to do we should do:
fd_pps = open("/dev/pps0", ...);
time_pps_create(fd_pps, &handle);
ok? Two qeustions:
1) If the RFC wan't broken why it doesn't simply say that you can use
fd_pps and pps handler?
2) How can you get kernel PPS source data just getting as input
fd_pps value?
Again, RFC was sane if it said that you can get a PPS hadler by simply
doing:
time_pps_create("/dev/pps0", &handle);
this could be easily implemented with just an open()...
They didn't like this because they __never__ considered the case where
the PPS source is not connected at all with any serial/parallel
decices.
On Mon, Jul 30, 2007 at 03:01:28PM +0530, Satyam Sharma wrote:
>
> What does the section on locking between hard irq contexts (or between
> user process context and hard irq context) say?
That I should use spin_lock_irqsave() but the document also:
1) says that I cannot hold spinlocks while sleeping and
2) doesn't say that using spin_lock/unlock() in user context and
spin_trylock/unlock() in interrupt context is wrong.
> As I said, you could just use the spin_lock_irqsave/restore() variants ...
> If you want, I can try and implement the other bits that I had suggested
> for the other things as well :-)
Great! Thanks a lot, so we can discuss on them and maybe we can prive
Linux of this PPS support! :)
Thanks a lot for your time, this discussion was most important for me
in better understanding locks problems (and also to improve my poor
english, eheheheh :).
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 14:55 ` Rodolfo Giometti
@ 2007-07-30 22:01 ` Satyam Sharma
2007-07-31 8:20 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-30 22:01 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi Rodolfo,
On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> On Mon, Jul 30, 2007 at 02:37:26PM +0530, Satyam Sharma wrote:
>
> > > Maybe you meant I should using spin_lock_irqsave/restore() in user
> > > context, but doing like this I will disable interrupts
> >
> > Yup, but the goal is to avoid races. Otherwise why bother doing any
> > locking at all?
>
> I meant that if you have to lock between user context and interrupt
> context you have two choises:
>
> 1) using spin_lock_irqsave/restore() in user context and spin_lock/unlock()
> in the interrupt context (as Rusty says),
Yes, but we need to use spin_lock_irqsave() from interrupt context to
synchronize between two hard irq contexts themselves.
> 2) or using spin_lock/unlock() in user context and
> spin_trylock/unlock() in the interrupt context in order to avoid dead
> locks.
Yup, this would avoid races, but then we will lose events. Why is that
acceptable, when better alternative (above) exists?
Seriously, your aversion to implement good, safe locking is amazing! :-)
> > > Of course, I meant "protecting data". In fact to protect pps_source[]
> > > I need spin_lock() to protect user context from interrupt context and
> > > mutex to protect user context from itself.
> >
> > But that's nonsensical! That's not how you implement locking!
> >
> > First, spin_lock() is *not* enough to protect access from process context
> > from access from interrupt context.
> >
> > Second, if you *already* have a lock to protect any data, introducing
> > *another* lock to protect the same data is ... utterly crazy!
>
> I see what you mean. But my question is about using spin_locks where
> we can sleep. Let me explain, consider sys_time_pps_getparams():
> [...]
> The copy_to_user() may sleep and if I change
> mutex_lock_interruptible() with a spin_lock I may hold it and then
> going to sleep... using mutex we can use the CPU for other
> computations.
The proper way to do this is to use a kernel buffer to do all kernel-side
work (you acquire/release lock during that work) and then copy_to_user()
later, at the end. [ And something opposite for the set_xxx syscall, i.e.
first off copy_from_user() to a kernel buffer up front, before doing
anything else itself, and then do all the work in the kernel on that. ]
BTW your syscall implementations totally lack any kind of security checks
whatsoever ...
> > > Why you wish using one lock per sources? Just one lock for the
> > > list/array is not enought? :-o
> >
> > No, I am *not* wishing / advocating that at all. Just that you appear so
> > _reluctant_ to use spinlocks and are unnecessarily worrying about
> > contention, disabling interrupts, etc etc.
> >
> > Just use the spin_lock_irqsave/restore() variants, and you'll be fine.
>
> What I wish is just to avoid disabling IRQs in user context in order
> to minimize the possibility to delay events recording.
Amazing. On the one hand, you want to use spin_trylock() in the hard irq
handler and spin_lock() (not irq safe) in the process context, because
you "don't care about losing some events". And now you want to avoid
"disabling irqs in user context to minimize possibility to delay events
recording"?
Anyway, any such requirement you're talking about is just bogus, IMHO.
You're just disabling interrupts to access a data structure, for Gods'
sakes, how many nanoseconds do you imagine would you be "delaying"?
> > > As you propose you need _two_ open() and not just one...
> >
> > No, why?
>
> Please, take alook at NTPD code. Common usage is:
>
> fd = open("/dev/ttyS0", ...);
>
> pps_time_create(fd, &handler);
>
> since RFC supposes that at filedes "fd" is mapped both GPS data _and_
> PPS source.
Umm, I don't think the RFC supposes/assumes this anywhere.
> Furthermore with my pps_findpath() I can do:
>
> fd = open("/dev/ttyS0", ...);
>
> handler = pps_findpath("/dev/ttyS0", ...);
>
> which in most cases its more easy to manage for both user and kernel
> land.
>
> Can do the same with char devices?
Of course. BTW time_pps_findpath/findsource do not have to be kernel
implemented syscalls in the first place. The best, simplest and most
straightforward place to implement them is in userspace -- the RFC
mentions this as well.
> Maybe you can easily create
> /dev/pps0 but how can you relate it with the /dev/ttyS0 if your GPS
> antenna and PPS source share the same serial port?
A solution I can think of is to create a mapping at the time of
pps_register_source() between the PPS source (physically) and the special
char device. Userspace open(2)'s the special char device corresponding to
the PPS source, and then issues the time_pps_create() syscall. Here, we
lookup the mapping previously created and return handle to the PPS source
based on the special device's fd that's passed to us in time_pps_create().
> > > I quite sure that RFC is broken since it doesn't take in account that
> > > a PPS source maybe not connected with any cahr device at all. I tried
> > > to explain this problem to RFC's gurus but they never answered to me,
> > > so I decided to resolve the problem by myself. ;)
> >
> > Nopes, the RFC is not broken at all. All this physical-connection-port
> > device vs PPS-source-device confusion is just in your mind :-)
>
> Ok, if you don't think so try looking at NTPD code (written by RFC's
> gurus) and try to resolve the problem where both GPS antenna and PPS
> source are connected with a serial port, and the problem where only
> the GPS antenna is connected with the serial port but the PPS source
> is connected with a CPU's GPIO.
>
> If you solve both them all PPS users will thank you a lot forever! :)
Ok, I'll take a look, thanks :-)
[ what's the URL for these sources? ]
> No, they require an _already_ opened file descriptor because they
> supposed you can use serial line file descriptor!
open(PPSfilename, O_RDWR) doesn't sound like that at all. If the device
for the serial port / parport was intended, it wouldn't be called
"PPSfilename", would it?
> Again, RFC was sane if it said that you can get a PPS hadler by simply
> doing:
>
> time_pps_create("/dev/pps0", &handle);
>
> this could be easily implemented with just an open()...
>
> They didn't like this because they __never__ considered the case where
> the PPS source is not connected at all with any serial/parallel
> decices.
The physical port/device through which a PPS source is connected is
immaterial. Anyway, I'll take a look at the NTPD/userspace code you are
mentioning as well. [ again, could you point me to URL of source code? ]
> > If you want, I can try and implement the other bits that I had suggested
> > for the other things as well :-)
>
> Great! Thanks a lot, so we can discuss on them and maybe we can prive
> Linux of this PPS support! :)
Sure, I'll get to implementing what I have in mind here -- will be glad
to be of any help, thanks.
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 22:01 ` Satyam Sharma
@ 2007-07-31 8:20 ` Rodolfo Giometti
2007-07-31 18:49 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-31 8:20 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Tue, Jul 31, 2007 at 03:31:22AM +0530, Satyam Sharma wrote:
> Hi Rodolfo,
Hi :)
> Yup, this would avoid races, but then we will lose events. Why is that
> acceptable, when better alternative (above) exists?
Because is better lossign events then recording them delayed. In the
past we (LinuxPPS users) noticed that just postponing of one
instruction the timestamp recording degrade the timesetting of about
50%!
> Seriously, your aversion to implement good, safe locking is amazing! :-)
I averse not by default. :) But I just wish understand _why_ a
solution is better then other.
I'm sure my solution is not the best at all, but before changing it I
wish understand if the new proposal is better.
> The proper way to do this is to use a kernel buffer to do all kernel-side
> work (you acquire/release lock during that work) and then copy_to_user()
> later, at the end. [ And something opposite for the set_xxx syscall, i.e.
> first off copy_from_user() to a kernel buffer up front, before doing
> anything else itself, and then do all the work in the kernel on that. ]
Mmm... I think this is not easy at all for sys_time_pps_fetch(). I
suppose you have to complicate its code a lot!
I don't undestand why we must complicate, and made unreadable, a code
in order to follow the rule use-only-one-lock-mechanism. If by using
mutex and spinlocks the code is more readable, where is the fault?
> BTW your syscall implementations totally lack any kind of security checks
> whatsoever ...
Ok, we can correct them. :)
> Amazing. On the one hand, you want to use spin_trylock() in the hard irq
> handler and spin_lock() (not irq safe) in the process context, because
> you "don't care about losing some events". And now you want to avoid
> "disabling irqs in user context to minimize possibility to delay events
> recording"?
Just for not delaying the IRQ handler. As already said, I prefere
loosing events that delaying their timestamps recording.
> Anyway, any such requirement you're talking about is just bogus, IMHO.
> You're just disabling interrupts to access a data structure, for Gods'
> sakes, how many nanoseconds do you imagine would you be "delaying"?
As already said we noticed that just delaying of one instruction the
timestamp recording the time setting degrades of about 50%.
We have to take care of this point. It's _very_ important that _each_
event had its timestamp recorded with delay as small as possible.
> > Please, take alook at NTPD code. Common usage is:
> >
> > fd = open("/dev/ttyS0", ...);
> >
> > pps_time_create(fd, &handler);
> >
> > since RFC supposes that at filedes "fd" is mapped both GPS data _and_
> > PPS source.
>
> Umm, I don't think the RFC supposes/assumes this anywhere.
I think so. If not, why they pretend an _already opened_ filedes then
just a filename to be used as parameter for the open(2) syscall? :)
Again, it was simpler, and more logic, define the time_pps_create as
follow:
time_pps_create(char *ppsdev, pps_handle_t *handle);
this definition resolves very well all possibile cases.
> Of course. BTW time_pps_findpath/findsource do not have to be kernel
> implemented syscalls in the first place. The best, simplest and most
> straightforward place to implement them is in userspace -- the RFC
> mentions this as well.
Ok, I'll wait for your modification to see how you can do it.
> A solution I can think of is to create a mapping at the time of
> pps_register_source() between the PPS source (physically) and the special
> char device. Userspace open(2)'s the special char device corresponding to
> the PPS source, and then issues the time_pps_create() syscall. Here, we
> lookup the mapping previously created and return handle to the PPS source
> based on the special device's fd that's passed to us in time_pps_create().
Ok, just what pps_findpath&C. does... however if you now how to
implement it I'll be very to see the code. :)
But, as you can see, this is due the bogus RFC specification. It was
more easier define the time_pps_create() as suggested above and you
didn't need no mapping at all.
> Ok, I'll take a look, thanks :-)
>
> [ what's the URL for these sources? ]
Oh, yes... sorry, here the NTP main site:
http://www.ntp.org
> open(PPSfilename, O_RDWR) doesn't sound like that at all. If the device
> for the serial port / parport was intended, it wouldn't be called
> "PPSfilename", would it?
No, I meant that if they require an already opened file descriptor is
beacuse they simply don't suppose that a PPS source may be totally
uncollerated to any device. If not they had two possibilities:
1) just using an open(2) to access a PPS source and using the returned
filedes as PPS handler,
2) or, just to be more general, define the time_pps_create() as above,
with the "char *ppsdevice" as parameter (then on UNIX systems we
implement it with open(2)).
> The physical port/device through which a PPS source is connected is
> immaterial. Anyway, I'll take a look at the NTPD/userspace code you are
> mentioning as well. [ again, could you point me to URL of source code? ]
http://www.ntp.org/downloads.html
> Sure, I'll get to implementing what I have in mind here -- will be glad
> to be of any help, thanks.
If you wish proving patches to LinuxPPS I just created a "develop"
branch into my GIT repository:
http://gitweb.enneenne.com/?p=linuxpps;a=shortlog;h=develop
Please, provide patch against that branch.
Thanks a lot,
Rodolfo
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-31 8:20 ` Rodolfo Giometti
@ 2007-07-31 18:49 ` Satyam Sharma
2007-07-31 19:44 ` Rodolfo Giometti
0 siblings, 1 reply; 43+ messages in thread
From: Satyam Sharma @ 2007-07-31 18:49 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Tue, 31 Jul 2007, Rodolfo Giometti wrote:
> On Tue, Jul 31, 2007 at 03:31:22AM +0530, Satyam Sharma wrote:
> > Yup, this would avoid races, but then we will lose events. Why is that
> > acceptable, when better alternative (above) exists?
>
> Because is better lossign events then recording them delayed. In the
> past we (LinuxPPS users) noticed that just postponing of one
> instruction the timestamp recording degrade the timesetting of about
> 50%!
> > Amazing. On the one hand, you want to use spin_trylock() in the hard irq
> > handler and spin_lock() (not irq safe) in the process context, because
> > you "don't care about losing some events". And now you want to avoid
> > "disabling irqs in user context to minimize possibility to delay events
> > recording"?
>
> Just for not delaying the IRQ handler. As already said, I prefere
> loosing events that delaying their timestamps recording.
> > Anyway, any such requirement you're talking about is just bogus, IMHO.
> > You're just disabling interrupts to access a data structure, for Gods'
> > sakes, how many nanoseconds do you imagine would you be "delaying"?
>
> As already said we noticed that just delaying of one instruction the
> timestamp recording the time setting degrades of about 50%.
>
> We have to take care of this point. It's _very_ important that _each_
> event had its timestamp recorded with delay as small as possible.
That's just absolute bullshit.
I'm sorry to say this, Rodolfo, but _all_ your arguments above are
*totally* nonsensical and factually incorrect -- and I have had enough of
trying to talk sense to you, it's been ~15 mails in this thread already,
and I've been WASTING my time trying to teach / explain to you, but it's
just *shocking* that you prefer to stick to a wholly incorrect (which I
suspect you've already understood by now anyway) position rather than
just accepting that the present patch is wrong and go about correcting
it instead.
> > The proper way to do this is to use a kernel buffer to do all kernel-side
> > work (you acquire/release lock during that work) and then copy_to_user()
> > later, at the end. [ And something opposite for the set_xxx syscall, i.e.
> > first off copy_from_user() to a kernel buffer up front, before doing
> > anything else itself, and then do all the work in the kernel on that. ]
>
> Mmm... I think this is not easy at all for sys_time_pps_fetch(). I
> suppose you have to complicate its code a lot!
>
> I don't undestand why we must complicate, and made unreadable, a code
> in order to follow the rule use-only-one-lock-mechanism. If by using
> mutex and spinlocks the code is more readable, where is the fault?
More nonsense. Utter nonsense. I really don't want to reply anymore ...
> > BTW your syscall implementations totally lack any kind of security checks
> > whatsoever ...
>
> Ok, we can correct them. :)
>
> > > Please, take alook at NTPD code. Common usage is:
> > >
> > > fd = open("/dev/ttyS0", ...);
> > >
> > > pps_time_create(fd, &handler);
> > >
> > > since RFC supposes that at filedes "fd" is mapped both GPS data _and_
> > > PPS source.
> >
> > Umm, I don't think the RFC supposes/assumes this anywhere.
>
> I think so. If not, why they pretend an _already opened_ filedes then
> just a filename to be used as parameter for the open(2) syscall? :)
Try reading the RFC again, please. And *think*.
Anyway, considering:
1. broken/nonsensical locking,
2. wrong (completely RFC non-compliant) implementation,
3. a syscall (time_pps_cmd) that has no semantics defined anywhere,
not even mandated by the RFC, is (as you yourself admitted)
a pseudo-ioctl for all practical purposes,
4. abject lack of security in the syscall implementations,
But MOST importantly:
5. your _sticking_ to the broken implementation and being so
(shockingly!) unwilling to correct these,
I really cannot see how I can support this stuff in getting merged
at all, sorry.
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-31 18:49 ` Satyam Sharma
@ 2007-07-31 19:44 ` Rodolfo Giometti
2007-07-31 21:15 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Rodolfo Giometti @ 2007-07-31 19:44 UTC (permalink / raw)
To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
On Wed, Aug 01, 2007 at 12:19:48AM +0530, Satyam Sharma wrote:
> That's just absolute bullshit.
...
> I'm sorry to say this, Rodolfo, but _all_ your arguments above are
> *totally* nonsensical and factually incorrect -- and I have had enough of
> trying to talk sense to you, it's been ~15 mails in this thread already,
> and I've been WASTING my time trying to teach / explain to you, but it's
> just *shocking* that you prefer to stick to a wholly incorrect (which I
> suspect you've already understood by now anyway) position rather than
> just accepting that the present patch is wrong and go about correcting
> it instead.
> [snip]
Sorry for wasting your time. :'( Maybe you can provide your solution
for PPS support and get it included into kernel tree so we can use it
and live happy! :)
Several people (Andrew, David, et all) wrote to me a lot of letters
without loosing their patience. I'm a poor programmer, not a «guru»
like you, and I need more time to understand things. I'm trying to do
my best. :)
However I'm very proud to be a "poor programmer" (slow in
understanding things) but a gentleman rather than a "kernel-guru" like
you but totally ill-mannered.
Thanks anyway for your (precious) time,
Rodolfo
P.S. A gentle programmer just wrote to me a letter where, proposing
code/patches, showed to me possible good solutions, so I think I'm
going to modify again the locking code soon.
--
GNU/Linux Solutions e-mail: giometti@enneenne.com
Linux Device Driver giometti@gnudd.com
Embedded Systems giometti@linux.it
UNIX programming phone: +39 349 2432127
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-31 19:44 ` Rodolfo Giometti
@ 2007-07-31 21:15 ` Satyam Sharma
0 siblings, 0 replies; 43+ messages in thread
From: Satyam Sharma @ 2007-07-31 21:15 UTC (permalink / raw)
To: Rodolfo Giometti
Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton
Hi,
On Tue, 31 Jul 2007, Rodolfo Giometti wrote:
> Sorry for wasting your time. :'( Maybe you can provide your solution
> for PPS support and get it included into kernel tree so we can use it
> and live happy! :)
Please stop embarrassing me (and yourself).
Sorry, I did lose my patience (others you mention did not) but then
that's precisely because of my own _less_ experience, if anything.
No, it's not like I "want to provide my solution for PPS support and
get it included into kernel tree" like you wrote above -- I simply
identified 4 problem areas in your implementation and wanted them to
be addressed. [If you can do so yourself, good enough, otherwise I'm
happy to send patch based on your earlier one too -- the modifications
I have in mind are few and simple.] I have no personal stake in this
PPS stuff anyway, this is just a normal peer review of submissions
that should always happen.
Thanks,
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-07-30 9:20 ` Satyam Sharma
@ 2007-08-01 22:14 ` Christopher Hoover
2007-08-01 23:03 ` Satyam Sharma
0 siblings, 1 reply; 43+ messages in thread
From: Christopher Hoover @ 2007-08-01 22:14 UTC (permalink / raw)
To: linux-kernel
Satyam Sharma <satyam <at> infradead.org> writes:
> On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
>
> > On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote:
> > Currently the RFC says to you that you should open the serial port:
> >
> > fd = open("/dev/ttyS0", ...);
>
> No, it does *NOT*. All it says is:
>
> The time_pps_create() is used to convert an already-open UNIX file
> descriptor, for an appropriate special file, into a PPS handle.
>
> See? What I said is precisely the implementation the RFC envisages
> (and the only sane way to implement it too).
If we were totally rigurous about representing each device as a device node,
your solution would be fine. But we don't.
The clocksource model (/sys/devices/system/clocksource) is a better way to
go. One sysfs file is used to enumerate the possible sources and another is
used to read or set the current source. No new system calls; no new ioctls.
-ch
ch (at) murgatroid (dot) com
ch (at) hpl (dot) hp (dot) com
^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks
2007-08-01 22:14 ` Christopher Hoover
@ 2007-08-01 23:03 ` Satyam Sharma
0 siblings, 0 replies; 43+ messages in thread
From: Satyam Sharma @ 2007-08-01 23:03 UTC (permalink / raw)
To: Christopher Hoover; +Cc: linux-kernel
Hi,
On Wed, 1 Aug 2007, Christopher Hoover wrote:
> Satyam Sharma <satyam <at> infradead.org> writes:
> > On Mon, 30 Jul 2007, Rodolfo Giometti wrote:
> >
> > > On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote:
> > > Currently the RFC says to you that you should open the serial port:
> > >
> > > fd = open("/dev/ttyS0", ...);
> >
> > No, it does *NOT*. All it says is:
> >
> > The time_pps_create() is used to convert an already-open UNIX file
> > descriptor, for an appropriate special file, into a PPS handle.
> >
> > See? What I said is precisely the implementation the RFC envisages
> > (and the only sane way to implement it too).
>
> If we were totally rigurous about representing each device as a device node,
> your solution would be fine. But we don't.
Of course.
> The clocksource model (/sys/devices/system/clocksource) is a better way to
> go. One sysfs file is used to enumerate the possible sources and another is
> used to read or set the current source. No new system calls; no new ioctls.
Oh, not introducing any syscalls _at all_ would be fine, too. But the
RFC does /require/ an implementation to have them. I was only mentioning
the kind of implementation the RFC had in mind. But there are other ways
to achieve the same end goal, and yes, probably it's better to avoid
introducing syscalls in the first place and think of other mechanisms.
[ It's not that we're talking of IPsec or IPv6 or something here --
so RFC-compliance isn't overly important. But the final result
needs to be good, secure and well-designed, still. ]
Satyam
^ permalink raw reply [flat|nested] 43+ messages in thread
end of thread, other threads:[~2007-08-01 22:51 UTC | newest]
Thread overview: 43+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2007-07-17 18:05 [PATCH] LinuxPPS - definitive version Rodolfo Giometti
2007-07-23 13:35 ` David Woodhouse
2007-07-23 16:04 ` Rodolfo Giometti
2007-07-23 19:28 ` Andrew Morton
2007-07-23 19:48 ` David Woodhouse
2007-07-24 8:00 ` Rodolfo Giometti
2007-07-24 13:49 ` David Woodhouse
2007-07-24 14:20 ` Rodolfo Giometti
2007-07-24 14:46 ` David Woodhouse
2007-07-24 14:52 ` David Woodhouse
2007-07-24 16:01 ` Rodolfo Giometti
2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti
2007-07-27 19:08 ` Chris Friesen
2007-07-27 19:28 ` Rodolfo Giometti
2007-07-27 19:40 ` Chris Friesen
2007-07-27 19:45 ` Rodolfo Giometti
2007-07-27 20:47 ` Satyam Sharma
2007-07-27 23:41 ` Satyam Sharma
2007-07-29 9:50 ` Rodolfo Giometti
2007-07-30 5:03 ` Satyam Sharma
2007-07-30 8:51 ` Rodolfo Giometti
2007-07-30 9:20 ` Satyam Sharma
2007-08-01 22:14 ` Christopher Hoover
2007-08-01 23:03 ` Satyam Sharma
2007-07-29 9:57 ` Rodolfo Giometti
2007-07-29 10:00 ` Rodolfo Giometti
2007-07-30 5:09 ` Satyam Sharma
2007-07-30 8:53 ` Rodolfo Giometti
2007-07-30 9:31 ` Satyam Sharma
2007-07-29 9:17 ` Rodolfo Giometti
2007-07-30 4:19 ` Satyam Sharma
2007-07-30 8:32 ` Rodolfo Giometti
2007-07-30 9:07 ` Satyam Sharma
2007-07-30 14:55 ` Rodolfo Giometti
2007-07-30 22:01 ` Satyam Sharma
2007-07-31 8:20 ` Rodolfo Giometti
2007-07-31 18:49 ` Satyam Sharma
2007-07-31 19:44 ` Rodolfo Giometti
2007-07-31 21:15 ` Satyam Sharma
2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti
2007-07-24 14:45 ` David Woodhouse
2007-07-24 16:09 ` Rodolfo Giometti
2007-07-26 19:52 ` Roman Zippel
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox