This patch set adds the PPS support into Linux.
PPS means "pulse per second" and its API is specified by RFC 2783
(Pulse-Per-Second API for UNIX-like Operating Systems, Version 1.0).
The code has been tested with the NTPD program
(http://www.eecis.udel.edu/~mills/ntp/html/index.html) and several GPS
antennae.
Please, note that since last submit a new line discipline has been added
in order to leave untouched the serial ports code (as suggested by Alan).
Rodolfo
--
b/Documentation/ABI/testing/sysfs-pps | 73 +++++++
b/Documentation/ioctl-number.txt | 2
b/Documentation/pps/Makefile | 28 ++
b/Documentation/pps/pps.txt | 172 +++++++++++++++++
b/Documentation/pps/ppsfind | 17 +
b/Documentation/pps/ppsldisc.c | 46 ++++
b/Documentation/pps/ppstest.c | 151 +++++++++++++++
b/Documentation/pps/timepps.h | 195 +++++++++++++++++++
b/Documentation/tty.txt | 4
b/MAINTAINERS | 7
b/arch/x86/kernel/irq_32.c | 18 +
b/arch/x86/kernel/irq_64.c | 22 ++
b/drivers/Kconfig | 2
b/drivers/Makefile | 1
b/drivers/char/lp.c | 61 ++++++
b/drivers/char/n_tty.c | 54 +++--
b/drivers/pps/Kconfig | 33 +++
b/drivers/pps/Makefile | 8
b/drivers/pps/clients/Kconfig | 18 +
b/drivers/pps/clients/Makefile | 9
b/drivers/pps/clients/ktimer.c | 124 ++++++++++++
b/drivers/pps/clients/pps-ldisc.c | 154 +++++++++++++++
b/drivers/pps/kapi.c | 322 ++++++++++++++++++++++++++++++++
b/drivers/pps/pps.c | 335 ++++++++++++++++++++++++++++++++++
b/drivers/pps/sysfs.c | 104 ++++++++++
b/drivers/serial/8250.c | 13 +
b/include/linux/Kbuild | 1
b/include/linux/parport.h | 22 ++
b/include/linux/pps.h | 202 ++++++++++++++++++++
b/include/linux/serial_core.h | 10 -
b/include/linux/tty.h | 16 +
b/include/linux/tty_ldisc.h | 10 +
drivers/pps/Kconfig | 14 +
drivers/pps/Makefile | 1
drivers/pps/clients/Kconfig | 17 +
drivers/pps/clients/Makefile | 1
drivers/pps/clients/pps-ldisc.c | 18 +
include/linux/pps.h | 1
include/linux/tty.h | 3
39 files changed, 2263 insertions(+), 26 deletions(-)
Adds support for the PPS sources connected with the interrupt pin of a
parallel port.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
drivers/char/lp.c | 61 +++++++++++++++++++++++++++++++++++++++++++
drivers/pps/clients/Kconfig | 10 +++++++
include/linux/parport.h | 22 +++++++++++++++
3 files changed, 93 insertions(+), 0 deletions(-)
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 3f2719b..84e0bb0 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -760,6 +760,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 };
@@ -831,6 +852,38 @@ static int lp_register(int nr, struct parport *port)
}
#endif
+#ifdef CONFIG_PPS_CLIENT_LP
+ port->pps_info.owner = THIS_MODULE;
+ port->pps_info.dev = port->dev;
+ 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);
+ 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 because port \"%s\" "
+ "is in polling mode\n",
+ port->pps_info.path);
+ }
+#endif
+
return 0;
}
@@ -873,6 +926,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_source);
+ 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/clients/Kconfig b/drivers/pps/clients/Kconfig
index 487c1c8..b4054cd 100644
--- a/drivers/pps/clients/Kconfig
+++ b/drivers/pps/clients/Kconfig
@@ -22,4 +22,14 @@ config PPS_CLIENT_LDISC
If you say yes here you get support for a PPS source connected
with the CD (Carrier Detect) pin of your serial port.
+comment "Parallel printer support (forced off)"
+ depends on !( PRINTER != n && !(PPS = m && PRINTER = y))
+
+config PPS_CLIENT_LP
+ bool "Parallel printer support"
+ depends on PRINTER != n && !(PPS = m && PRINTER = y)
+ 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/include/linux/parport.h b/include/linux/parport.h
index 6a0d7cd..f2cfd6e 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 <linux/irqreturn.h>
#include <linux/semaphore.h>
#include <asm/system.h>
@@ -328,6 +329,11 @@ struct parport {
struct list_head full_list;
struct parport *slaves[3];
+
+#ifdef CONFIG_PPS_CLIENT_LP
+ struct pps_source_info pps_info;
+ int pps_source; /* PPS source ID */
+#endif
};
#define DEFAULT_SPIN_TIME 500 /* us */
@@ -516,6 +522,22 @@ 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(struct parport *port)
{
+#ifdef CONFIG_PPS_CLIENT_LP
+ 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;
+
+ pps_event(port->pps_source, &ts, PPS_CAPTUREASSERT, port);
+ dev_dbg(port->dev, "PPS assert at %lu on source #%d\n",
+ jiffies, port->pps_source);
+#endif
+
parport_ieee1284_interrupt (port);
read_lock(&port->cad_lock);
if (port->cad && port->cad->irq_func)
--
1.5.4.3
Signed-off-by: Rodolfo Giometti <[email protected]>
---
Documentation/tty.txt | 4 ++++
include/linux/tty_ldisc.h | 10 ++++++++++
2 files changed, 14 insertions(+), 0 deletions(-)
diff --git a/Documentation/tty.txt b/Documentation/tty.txt
index 8e65c44..3fc812a 100644
--- a/Documentation/tty.txt
+++ b/Documentation/tty.txt
@@ -100,6 +100,10 @@ write_wakeup() - May be called at any point between open and close.
is permitted to call the driver write method from
this function. In such a situation defer it.
+dcd_change() - Report to the tty line the current DCD pin status
+ changes and the relative timestamp. The timestamp
+ can be NULL.
+
Driver Access
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 40f38d8..e74a28b 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -99,11 +99,19 @@
* cease I/O to the tty driver. Can sleep. The driver should
* seek to perform this action quickly but should wait until
* any pending driver I/O is completed.
+ *
+ * void (*dcd_change)(struct uart_port *port, unsigned int status,
+ * struct timespec *ts)
+ *
+ * Tells the discipline that the DCD pin has changed its status and
+ * the relative timestamp. Pointer ts can be NULL.
*/
#include <linux/fs.h>
#include <linux/wait.h>
+struct uart_port;
+
struct tty_ldisc_ops {
int magic;
char *name;
@@ -136,6 +144,8 @@ struct tty_ldisc_ops {
void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
char *fp, int count);
void (*write_wakeup)(struct tty_struct *);
+ void (*dcd_change)(struct uart_port *, unsigned int,
+ struct timespec *);
struct module *owner;
--
1.5.4.3
Each PPS source can be registered/deregistered into the system by
using special modules called "clients". They simply define the PPS
sources' attributes and implement the time signal registartion
mechanism.
This patch adds a special directory for such clients and adds a dummy
client that can be useful to test system integrity on real systems.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
drivers/pps/Kconfig | 2 +
drivers/pps/Makefile | 1 +
drivers/pps/clients/Kconfig | 18 ++++++
drivers/pps/clients/Makefile | 9 +++
drivers/pps/clients/ktimer.c | 124 ++++++++++++++++++++++++++++++++++++++++++
5 files changed, 154 insertions(+), 0 deletions(-)
create mode 100644 drivers/pps/clients/Kconfig
create mode 100644 drivers/pps/clients/Makefile
create mode 100644 drivers/pps/clients/ktimer.c
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
index cc2eb8e..1afe4e0 100644
--- a/drivers/pps/Kconfig
+++ b/drivers/pps/Kconfig
@@ -30,4 +30,6 @@ config PPS_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
index 19ea582..98960dd 100644
--- a/drivers/pps/Makefile
+++ b/drivers/pps/Makefile
@@ -4,5 +4,6 @@
pps_core-y := pps.o kapi.o sysfs.o
obj-$(CONFIG_PPS) := pps_core.o
+obj-y += clients/
ccflags-$(CONFIG_PPS_DEBUG) := -DDEBUG
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 0000000..60b83be
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,18 @@
+#
+# 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.
+
+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..259baa7
--- /dev/null
+++ b/drivers/pps/clients/ktimer.c
@@ -0,0 +1,124 @@
+/*
+ * ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006 Rodolfo Giometti <[email protected]>
+ *
+ * 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)
+{
+ struct timespec __ts;
+ struct pps_ktime ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&__ts);
+
+ pr_info("PPS event at %lu\n", jiffies);
+
+ /* ... and translate it to PPS time data struct */
+ ts.sec = __ts.tv_sec;
+ ts.nsec = __ts.tv_nsec;
+
+ pps_event(source, &ts, 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 pps_ktimer_info = {
+ .name = "ktimer",
+ .path = "",
+ .mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ .echo = pps_ktimer_echo,
+ .owner = THIS_MODULE,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+ del_timer_sync(&ktimer);
+ pps_unregister_source(source);
+
+ 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);
+ 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 <[email protected]>");
+MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
--
1.5.4.3
Here some utilities and examples about the PPS API and the LinuxPPS
support.
* ppsldisc.c shows how to manage PPS line discipline;
* ppstest.c implements an useful testing program, while
* ppsfind tries to help the user into finding a specific PPS source by
using its name or path.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
Documentation/pps/Makefile | 28 ++++++++
Documentation/pps/ppsfind | 17 +++++
Documentation/pps/ppsldisc.c | 46 +++++++++++++
Documentation/pps/ppstest.c | 151 ++++++++++++++++++++++++++++++++++++++++++
4 files changed, 242 insertions(+), 0 deletions(-)
create mode 100644 Documentation/pps/Makefile
create mode 100644 Documentation/pps/ppsfind
create mode 100644 Documentation/pps/ppsldisc.c
create mode 100644 Documentation/pps/ppstest.c
diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
new file mode 100644
index 0000000..9841e6b
--- /dev/null
+++ b/Documentation/pps/Makefile
@@ -0,0 +1,28 @@
+TARGETS = ppstest ppsldisc
+
+CFLAGS += -Wall -O2 -D_GNU_SOURCE
+CFLAGS += -I .
+CFLAGS += -ggdb
+CFLAGS += -D__N_PPS=$(shell awk '/N_PPS/ {print $$3}' ../../include/linux/tty.h)
+
+# -- 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/ppsfind b/Documentation/pps/ppsfind
new file mode 100644
index 0000000..93c0e17
--- /dev/null
+++ b/Documentation/pps/ppsfind
@@ -0,0 +1,17 @@
+#!/bin/sh
+
+SYS="/sys/class/pps/"
+
+if [ $# -lt 1 ] ; then
+ echo "usage: ppsfind <name>" >&2
+ exit 1
+fi
+
+for d in $(ls $SYS) ; do
+ if grep $1 $SYS/$d/name >& /dev/null || \
+ grep $1 $SYS/$d/path >& /dev/null ; then
+ echo "$d: name=$(cat $SYS/$d/name) path=$(cat $SYS/$d/path)"
+ fi
+done
+
+exit 0
diff --git a/Documentation/pps/ppsldisc.c b/Documentation/pps/ppsldisc.c
new file mode 100644
index 0000000..036e13b
--- /dev/null
+++ b/Documentation/pps/ppsldisc.c
@@ -0,0 +1,46 @@
+#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>
+
+#ifndef N_PPS
+#define N_PPS __N_PPS
+#endif
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ttyS>\n", name);
+
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd;
+ int ldisc = N_PPS;
+ int ret;
+
+ if (argc < 2)
+ usage(argv[0]);
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0) {
+ perror("open");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = ioctl(fd, TIOCSETD, &ldisc);
+ if (ret < 0) {
+ perror("ioctl(TIOCSETD)");
+ exit(EXIT_FAILURE);
+ }
+
+ pause();
+
+ return 0;
+}
diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
new file mode 100644
index 0000000..d125ffa
--- /dev/null
+++ b/Documentation/pps/ppstest.c
@@ -0,0 +1,151 @@
+#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>
+
+int find_source(char *path, pps_handle_t *handle, int *avail_mode)
+{
+ pps_params_t params;
+ int ret;
+
+ printf("trying PPS source \"%s\"\n", path);
+
+ /* Try to find the source by using the supplied "path" name */
+ ret = open(path, O_RDWR);
+ if (ret < 0) {
+ fprintf(stderr, "unable to open device \"%s\" (%m)\n", path);
+ return ret;
+ }
+
+ /* Open the PPS source (and check the file descriptor) */
+ ret = time_pps_create(ret, handle);
+ if (ret < 0) {
+ fprintf(stderr, "cannot create a PPS source from device "
+ "\"%s\" (%m)\n", path);
+ return -1;
+ }
+ printf("found PPS source \"%s\"\n", path);
+
+ /* 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;
+}
+
+void usage(char *name)
+{
+ fprintf(stderr, "usage: %s <ppsdev> [<ppsdev> ...]\n", name);
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+ int num;
+ pps_handle_t handle[4];
+ int avail_mode[4];
+ int i = 0;
+ int ret;
+
+ /* Check the command line */
+ if (argc < 2)
+ usage(argv[0]);
+
+ for (i = 1; i < argc && i <= 4; i++) {
+ ret = find_source(argv[i], &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;
+}
--
1.5.4.3
This patch adds into the PPS's documentation directory a possible
implementation of the PPS API (RFC 2783) by using the LinuxPPS's char
devices.
This file is not just an example but it can be used into real
systems. :)
Signed-off-by: Rodolfo Giometti <[email protected]>
---
Documentation/pps/timepps.h | 195 +++++++++++++++++++++++++++++++++++++++++++
1 files changed, 195 insertions(+), 0 deletions(-)
create mode 100644 Documentation/pps/timepps.h
diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
new file mode 100644
index 0000000..2372949
--- /dev/null
+++ b/Documentation/pps/timepps.h
@@ -0,0 +1,195 @@
+/*
+ * timepps.h -- PPS API main header
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <[email protected]>
+ *
+ * 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>
+
+#define LINUXPPS 1 /* signal we are using LinuxPPS */
+
+/*
+ * 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 for 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
+ */
+
+static __inline int time_pps_create(int source, pps_handle_t *handle)
+{
+ int ret;
+
+ if (!handle) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* First we check if current device is a PPS valid PPS one...
+ */
+ ret = ioctl(source, PPS_CHECK);
+ if (ret) {
+ errno = EOPNOTSUPP;
+ return -1;
+ }
+
+ /* ... then since in LinuxPPS there are no differences between a
+ * "PPS source" and a "PPS handle", we simply return the same value.
+ */
+ *handle = source;
+
+ return 0;
+}
+
+static __inline int time_pps_destroy(pps_handle_t handle)
+{
+ return close(handle);
+}
+
+static __inline int time_pps_getparams(pps_handle_t handle,
+ pps_params_t *ppsparams)
+{
+ int ret;
+ struct pps_kparams __ppsparams;
+
+ ret = ioctl(handle, PPS_GETPARAMS, &__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;
+}
+
+static __inline 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 ioctl(handle, PPS_SETPARAMS, &__ppsparams);
+}
+
+/* Get capabilities for handle */
+static __inline int time_pps_getcap(pps_handle_t handle, int *mode)
+{
+ return ioctl(handle, PPS_GETCAP, mode);
+}
+
+static __inline int time_pps_fetch(pps_handle_t handle, const int tsformat,
+ pps_info_t *ppsinfobuf,
+ const struct timespec *timeout)
+{
+ struct pps_fdata __fdata;
+ int ret;
+
+ /* Sanity checks */
+ if (tsformat != PPS_TSFMT_TSPEC) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (timeout) {
+ __fdata.timeout.sec = timeout->tv_sec;
+ __fdata.timeout.nsec = timeout->tv_nsec;
+ __fdata.timeout.flags = ~PPS_TIME_INVALID;
+ } else
+ __fdata.timeout.flags = PPS_TIME_INVALID;
+
+ ret = ioctl(handle, PPS_FETCH, &__fdata);
+
+ ppsinfobuf->assert_sequence = __fdata.info.assert_sequence;
+ ppsinfobuf->clear_sequence = __fdata.info.clear_sequence;
+ ppsinfobuf->assert_tu.tspec.tv_sec = __fdata.info.assert_tu.sec;
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __fdata.info.assert_tu.nsec;
+ ppsinfobuf->clear_tu.tspec.tv_sec = __fdata.info.clear_tu.sec;
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __fdata.info.clear_tu.nsec;
+ ppsinfobuf->current_mode = __fdata.info.current_mode;
+
+ return ret;
+}
+
+static __inline 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_ */
--
1.5.4.3
Add low level IRQ timestamps recording for x86 (32 and 64 bits)
platforms and enable UART clients in order to use it.
This improves PPS precision. :)
Signed-off-by: Rodolfo Giometti <[email protected]>
---
arch/x86/kernel/irq_32.c | 18 ++++++++++++++++++
arch/x86/kernel/irq_64.c | 22 ++++++++++++++++++++--
drivers/pps/Kconfig | 12 ++++++++++++
drivers/pps/clients/pps-ldisc.c | 18 ++++++++++++++++++
include/linux/pps.h | 1 +
5 files changed, 69 insertions(+), 2 deletions(-)
diff --git a/arch/x86/kernel/irq_32.c b/arch/x86/kernel/irq_32.c
index 1cf8c1f..3013d0d 100644
--- a/arch/x86/kernel/irq_32.c
+++ b/arch/x86/kernel/irq_32.c
@@ -15,6 +15,7 @@
#include <linux/notifier.h>
#include <linux/cpu.h>
#include <linux/delay.h>
+#include <linux/pps.h>
#include <asm/apic.h>
#include <asm/uaccess.h>
@@ -25,6 +26,11 @@ EXPORT_PER_CPU_SYMBOL(irq_stat);
DEFINE_PER_CPU(struct pt_regs *, irq_regs);
EXPORT_PER_CPU_SYMBOL(irq_regs);
+#ifdef CONFIG_PPS_IRQ_EVENTS
+struct pps_ktime pps_irq_ts[NR_IRQS];
+EXPORT_SYMBOL(pps_irq_ts);
+#endif
+
/*
* 'what should we do if we get a hw irq event on an illegal vector'.
* each architecture has to answer this themselves.
@@ -225,6 +231,12 @@ unsigned int do_IRQ(struct pt_regs *regs)
/* high bit used in ret_from_ code */
int overflow, irq = ~regs->orig_ax;
struct irq_desc *desc = irq_desc + irq;
+#ifdef CONFIG_PPS_IRQ_EVENTS
+ struct timespec __ts;
+
+ /* Get IRQ timestamps as soon as possible for the PPS layer */
+ getnstimeofday(&__ts);
+#endif
if (unlikely((unsigned)irq >= NR_IRQS)) {
printk(KERN_EMERG "%s: cannot handle IRQ %d\n",
@@ -232,6 +244,12 @@ unsigned int do_IRQ(struct pt_regs *regs)
BUG();
}
+#ifdef CONFIG_PPS_IRQ_EVENTS
+ /* Then, after sanity check, store the IRQ timestamp */
+ pps_irq_ts[irq].sec = __ts.tv_sec;
+ pps_irq_ts[irq].nsec = __ts.tv_nsec;
+#endif
+
old_regs = set_irq_regs(regs);
irq_enter();
diff --git a/arch/x86/kernel/irq_64.c b/arch/x86/kernel/irq_64.c
index 1f78b23..1ea77a7 100644
--- a/arch/x86/kernel/irq_64.c
+++ b/arch/x86/kernel/irq_64.c
@@ -17,9 +17,15 @@
#include <asm/io_apic.h>
#include <asm/idle.h>
#include <asm/smp.h>
+#include <linux/pps.h>
atomic_t irq_err_count;
+#ifdef CONFIG_PPS_IRQ_EVENTS
+struct pps_ktime pps_irq_ts[NR_IRQS];
+EXPORT_SYMBOL(pps_irq_ts);
+#endif
+
/*
* 'what should we do if we get a hw irq event on an illegal vector'.
* each architecture has to answer this themselves.
@@ -188,6 +194,12 @@ u64 arch_irq_stat(void)
asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
+#ifdef CONFIG_PPS_IRQ_EVENTS
+ struct timespec __ts;
+
+ /* Get IRQ timestamps as soon as possible for the PPS layer */
+ getnstimeofday(&__ts);
+#endif
/* high bit used in ret_from_ code */
unsigned vector = ~regs->orig_ax;
@@ -201,9 +213,15 @@ asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
stack_overflow_check(regs);
#endif
- if (likely(irq < NR_IRQS))
+ if (likely(irq < NR_IRQS)) {
+#ifdef CONFIG_PPS_IRQ_EVENTS
+ /* Then, after sanity check, store the IRQ timestamp */
+ pps_irq_ts[irq].sec = __ts.tv_sec;
+ pps_irq_ts[irq].nsec = __ts.tv_nsec;
+#endif
+
generic_handle_irq(irq);
- else {
+ } else {
if (!disable_apic)
ack_APIC_irq();
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
index 1afe4e0..7c0b094 100644
--- a/drivers/pps/Kconfig
+++ b/drivers/pps/Kconfig
@@ -22,6 +22,18 @@ config PPS
To compile this driver as a module, choose M here: the module
will be called pps_core.ko.
+config PPS_IRQ_EVENTS
+ bool "Use low level IRQ timestamps"
+ depends on PPS && (X86_32 || X86_64)
+ default yes
+ help
+ Say Y here if you wish using low level IRQ timestamps to register
+ PPS events.
+
+ This should improve PPS resolution but it delays echo functions
+ call. Note also that this function is not implemented on all
+ platforms and PPS clients!
+
config PPS_DEBUG
bool "PPS debugging messages"
depends on PPS
diff --git a/drivers/pps/clients/pps-ldisc.c b/drivers/pps/clients/pps-ldisc.c
index f1efa26..20d2c2e 100644
--- a/drivers/pps/clients/pps-ldisc.c
+++ b/drivers/pps/clients/pps-ldisc.c
@@ -26,6 +26,22 @@
#define PPS_TTY_MAGIC 0x0001
+#ifdef CONFIG_PPS_IRQ_EVENTS
+
+static void pps_tty_dcd_change(struct uart_port *port, unsigned int status,
+ struct timespec *ts)
+{
+ int id = (int) port->info->port.tty->disc_data;
+
+ pps_event(id, &pps_irq_ts[port->irq],
+ status ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR, port);
+
+ pr_debug("[IRQev] PPS %s at %lu on source #%d\n",
+ status ? "assert" : "clear", jiffies, id);
+}
+
+#else
+
static void pps_tty_dcd_change(struct uart_port *port, unsigned int status,
struct timespec *ts)
{
@@ -53,6 +69,8 @@ static void pps_tty_dcd_change(struct uart_port *port, unsigned int status,
status ? "assert" : "clear", jiffies, id);
}
+#endif /* CONFIG_PPS_IRQ_EVENTS */
+
static int pps_tty_open(struct tty_struct *tty)
{
struct pps_source_info info;
diff --git a/include/linux/pps.h b/include/linux/pps.h
index 53e171c..bb9a2e6 100644
--- a/include/linux/pps.h
+++ b/include/linux/pps.h
@@ -181,6 +181,7 @@ struct pps_device {
extern spinlock_t pps_idr_lock;
extern struct idr pps_idr;
+extern struct pps_ktime pps_irq_ts[];
extern struct device_attribute pps_attrs[];
--
1.5.4.3
Signed-off-by: Rodolfo Giometti <[email protected]>
---
drivers/char/n_tty.c | 54 +++++++++++++++++++++++++++++--------------------
include/linux/tty.h | 16 ++++++++++++++
2 files changed, 48 insertions(+), 22 deletions(-)
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index 708c2b1..10d037e 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -26,7 +26,7 @@
*
* 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
* waiting writing processes-Sapan Bhatia <[email protected]>.
- * Also fixed a bug in BLOCKING mode where write_chan returns
+ * Also fixed a bug in BLOCKING mode where n_tty_write returns
* EAGAIN
*/
@@ -43,10 +43,10 @@
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/slab.h>
-#include <linux/poll.h>
#include <linux/bitops.h>
#include <linux/audit.h>
#include <linux/file.h>
+#include <linux/module.h>
#include <asm/uaccess.h>
#include <asm/system.h>
@@ -184,7 +184,7 @@ static void reset_buffer_flags(struct tty_struct *tty)
* Locking: ctrl_lock
*/
-static void n_tty_flush_buffer(struct tty_struct *tty)
+void n_tty_flush_buffer(struct tty_struct *tty)
{
unsigned long flags;
/* clear everything and unthrottle the driver */
@@ -200,6 +200,7 @@ static void n_tty_flush_buffer(struct tty_struct *tty)
}
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
}
+EXPORT_SYMBOL(n_tty_flush_buffer);
/**
* n_tty_chars_in_buffer - report available bytes
@@ -209,7 +210,7 @@ static void n_tty_flush_buffer(struct tty_struct *tty)
* at this instant in time.
*/
-static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
+ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
{
unsigned long flags;
ssize_t n = 0;
@@ -225,6 +226,7 @@ static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
spin_unlock_irqrestore(&tty->read_lock, flags);
return n;
}
+EXPORT_SYMBOL(n_tty_chars_in_buffer);
/**
* is_utf8_continuation - utf8 multibyte check
@@ -346,7 +348,7 @@ static int opost(unsigned char c, struct tty_struct *tty)
* the simple cases normally found and helps to generate blocks of
* symbols for the console driver and thus improve performance.
*
- * Called from write_chan under the tty layer write lock. Relies
+ * Called from n_tty_write under the tty layer write lock. Relies
* on lock_kernel for the tty->column state.
*/
@@ -895,13 +897,14 @@ handle_newline:
* IO must be woken up
*/
-static void n_tty_write_wakeup(struct tty_struct *tty)
+void n_tty_write_wakeup(struct tty_struct *tty)
{
if (tty->fasync) {
set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
}
}
+EXPORT_SYMBOL(n_tty_write_wakeup);
/**
* n_tty_receive_buf - data receive
@@ -916,7 +919,7 @@ static void n_tty_write_wakeup(struct tty_struct *tty)
* calls one at a time and in order (or using flush_to_ldisc)
*/
-static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
+void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
char *fp, int count)
{
const unsigned char *p;
@@ -990,6 +993,7 @@ static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
tty_throttle(tty);
}
+EXPORT_SYMBOL(n_tty_receive_buf);
int is_ignored(int sig)
{
@@ -1009,7 +1013,7 @@ int is_ignored(int sig)
* when the ldisc is closed.
*/
-static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
+void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
{
if (!tty)
return;
@@ -1076,6 +1080,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
wake_up_interruptible(&tty->write_wait);
wake_up_interruptible(&tty->read_wait);
}
+EXPORT_SYMBOL(n_tty_set_termios);
/**
* n_tty_close - close the ldisc for this tty
@@ -1087,7 +1092,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
* ldisc methods are in progress.
*/
-static void n_tty_close(struct tty_struct *tty)
+void n_tty_close(struct tty_struct *tty)
{
n_tty_flush_buffer(tty);
if (tty->read_buf) {
@@ -1095,6 +1100,7 @@ static void n_tty_close(struct tty_struct *tty)
tty->read_buf = NULL;
}
}
+EXPORT_SYMBOL(n_tty_close);
/**
* n_tty_open - open an ldisc
@@ -1106,7 +1112,7 @@ static void n_tty_close(struct tty_struct *tty)
* until a close.
*/
-static int n_tty_open(struct tty_struct *tty)
+int n_tty_open(struct tty_struct *tty)
{
if (!tty)
return -EINVAL;
@@ -1125,6 +1131,7 @@ static int n_tty_open(struct tty_struct *tty)
tty->closing = 0;
return 0;
}
+EXPORT_SYMBOL(n_tty_open);
static inline int input_available_p(struct tty_struct *tty, int amt)
{
@@ -1143,7 +1150,7 @@ static inline int input_available_p(struct tty_struct *tty, int amt)
* @b: user data
* @nr: size of data
*
- * Helper function to speed up read_chan. It is only called when
+ * Helper function to speed up n_tty_read. It is only called when
* ICANON is off; it copies characters straight from the tty queue to
* user space directly. It can be profitably called twice; once to
* drain the space from the tail pointer to the (physical) end of the
@@ -1210,7 +1217,7 @@ static int job_control(struct tty_struct *tty, struct file *file)
if (file->f_op->write != redirected_tty_write &&
current->signal->tty == tty) {
if (!tty->pgrp)
- printk(KERN_ERR "read_chan: no tty->pgrp!\n");
+ printk(KERN_ERR "n_tty_read: no tty->pgrp!\n");
else if (task_pgrp(current) != tty->pgrp) {
if (is_ignored(SIGTTIN) ||
is_current_pgrp_orphaned())
@@ -1225,7 +1232,7 @@ static int job_control(struct tty_struct *tty, struct file *file)
/**
- * read_chan - read function for tty
+ * n_tty_read - read function for tty
* @tty: tty device
* @file: file object
* @buf: userspace buffer pointer
@@ -1239,7 +1246,7 @@ static int job_control(struct tty_struct *tty, struct file *file)
* This code must be sure never to sleep through a hangup.
*/
-static ssize_t read_chan(struct tty_struct *tty, struct file *file,
+ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
unsigned char __user *buf, size_t nr)
{
unsigned char __user *b = buf;
@@ -1255,7 +1262,7 @@ static ssize_t read_chan(struct tty_struct *tty, struct file *file,
do_it_again:
if (!tty->read_buf) {
- printk(KERN_ERR "n_tty_read_chan: read_buf == NULL?!?\n");
+ printk(KERN_ERR "n_tty_read: read_buf == NULL?!?\n");
return -EIO;
}
@@ -1442,9 +1449,10 @@ do_it_again:
n_tty_set_room(tty);
return retval;
}
+EXPORT_SYMBOL(n_tty_read);
/**
- * write_chan - write function for tty
+ * n_tty_write - write function for tty
* @tty: tty device
* @file: file object
* @buf: userspace buffer pointer
@@ -1458,7 +1466,7 @@ do_it_again:
* This code must be sure never to sleep through a hangup.
*/
-static ssize_t write_chan(struct tty_struct *tty, struct file *file,
+ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
const unsigned char *buf, size_t nr)
{
const unsigned char *b = buf;
@@ -1530,9 +1538,10 @@ break_out:
remove_wait_queue(&tty->write_wait, &wait);
return (b - buf) ? b - buf : retval;
}
+EXPORT_SYMBOL(n_tty_write);
/**
- * normal_poll - poll method for N_TTY
+ * n_tty_poll - poll method for N_TTY
* @tty: terminal device
* @file: file accessing it
* @wait: poll table
@@ -1545,7 +1554,7 @@ break_out:
* Called without the kernel lock held - fine
*/
-static unsigned int normal_poll(struct tty_struct *tty, struct file *file,
+unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
poll_table *wait)
{
unsigned int mask = 0;
@@ -1572,6 +1581,7 @@ static unsigned int normal_poll(struct tty_struct *tty, struct file *file,
mask |= POLLOUT | POLLWRNORM;
return mask;
}
+EXPORT_SYMBOL(n_tty_poll);
struct tty_ldisc_ops tty_ldisc_N_TTY = {
.magic = TTY_LDISC_MAGIC,
@@ -1580,11 +1590,11 @@ struct tty_ldisc_ops tty_ldisc_N_TTY = {
.close = n_tty_close,
.flush_buffer = n_tty_flush_buffer,
.chars_in_buffer = n_tty_chars_in_buffer,
- .read = read_chan,
- .write = write_chan,
+ .read = n_tty_read,
+ .write = n_tty_write,
.ioctl = n_tty_ioctl,
.set_termios = n_tty_set_termios,
- .poll = normal_poll,
+ .poll = n_tty_poll,
.receive_buf = n_tty_receive_buf,
.write_wakeup = n_tty_write_wakeup
};
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 0cbec74..826d695 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -13,6 +13,7 @@
#include <linux/tty_driver.h>
#include <linux/tty_ldisc.h>
#include <linux/mutex.h>
+#include <linux/poll.h>
#include <asm/system.h>
@@ -393,6 +394,21 @@ extern void tty_ldisc_begin(void);
/* This last one is just for the tty layer internals and shouldn't be used elsewhere */
extern void tty_ldisc_enable(struct tty_struct *tty);
+extern void n_tty_flush_buffer(struct tty_struct *tty);
+extern ssize_t n_tty_chars_in_buffer(struct tty_struct *tty);
+extern void n_tty_write_wakeup(struct tty_struct *tty);
+extern void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
+ char *fp, int count);
+extern void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old);
+extern void n_tty_close(struct tty_struct *tty);
+extern int n_tty_open(struct tty_struct *tty);
+extern ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
+ unsigned char __user *buf, size_t nr);
+extern ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
+ const unsigned char *buf, size_t nr);
+extern unsigned int n_tty_poll(struct tty_struct *tty, struct file *file,
+ poll_table *wait);
+
/* n_tty.c */
extern struct tty_ldisc_ops tty_ldisc_N_TTY;
--
1.5.4.3
This patch adds the kernel side of the PPS support currently named
"LinuxPPS".
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.
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.
To obtain this goal the userland programs shoud use the PPS API
specification (RFC 2783 - Pulse-Per-Second API for UNIX-like Operating
Systems, Version 1.0) which in part is implemented by this patch. It
provides a set of chars devices, one per PPS source, which can be used
to get the time signal. The RFC's functions can be implemented by
accessing to these char devices.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
Documentation/ABI/testing/sysfs-pps | 73 ++++++++
Documentation/ioctl-number.txt | 2 +
Documentation/pps/pps.txt | 172 ++++++++++++++++++
MAINTAINERS | 7 +
drivers/Kconfig | 2 +
drivers/Makefile | 1 +
drivers/pps/Kconfig | 33 ++++
drivers/pps/Makefile | 8 +
drivers/pps/kapi.c | 322 +++++++++++++++++++++++++++++++++
drivers/pps/pps.c | 335 +++++++++++++++++++++++++++++++++++
drivers/pps/sysfs.c | 104 +++++++++++
include/linux/Kbuild | 1 +
include/linux/pps.h | 202 +++++++++++++++++++++
13 files changed, 1262 insertions(+), 0 deletions(-)
create mode 100644 Documentation/ABI/testing/sysfs-pps
create mode 100644 Documentation/pps/pps.txt
create mode 100644 drivers/pps/Kconfig
create mode 100644 drivers/pps/Makefile
create mode 100644 drivers/pps/kapi.c
create mode 100644 drivers/pps/pps.c
create mode 100644 drivers/pps/sysfs.c
create mode 100644 include/linux/pps.h
diff --git a/Documentation/ABI/testing/sysfs-pps b/Documentation/ABI/testing/sysfs-pps
new file mode 100644
index 0000000..8cba1d9
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-pps
@@ -0,0 +1,73 @@
+What: /sys/class/pps/
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ directory will contain files and
+ directories that will provide a unified interface to
+ the PPS sources.
+
+What: /sys/class/pps/ppsX/
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/ directory is related to X-th
+ PPS source into the system. Each directory will
+ contain files to manage and control its PPS source.
+
+What: /sys/class/pps/ppsX/assert
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/assert file reports the assert events
+ and the assert sequence number of the X-th source in the form:
+
+ <secs>.<nsec>#<sequence>
+
+ If the source has no assert events the content of this file
+ is void.
+
+What: /sys/class/pps/ppsX/clear
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/clear file reports the clear events
+ and the clear sequence number of the X-th source in the form:
+
+ <secs>.<nsec>#<sequence>
+
+ If the source has no clear events the content of this file
+ is void.
+
+What: /sys/class/pps/ppsX/mode
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/mode file reports the functioning
+ mode of the X-th source in hexadecimal encoding.
+
+ Please, refer to linux/include/linux/pps.h for further
+ info.
+
+What: /sys/class/pps/ppsX/echo
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/echo file reports if the X-th source
+ supports or not an "echo" function.
+
+What: /sys/class/pps/ppsX/name
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/name file reports the name of the
+ X-th source.
+
+What: /sys/class/pps/ppsX/path
+Date: February 2008
+Contact: Rodolfo Giometti <[email protected]>
+Description:
+ The /sys/class/pps/ppsX/path file reports the path name of
+ the device connected with the X-th source.
+
+ If the source is not connected with any device the content
+ of this file is void.
diff --git a/Documentation/ioctl-number.txt b/Documentation/ioctl-number.txt
index 1c6b545..963516d 100644
--- a/Documentation/ioctl-number.txt
+++ b/Documentation/ioctl-number.txt
@@ -97,6 +97,8 @@ Code Seq# Include File Comments
'M' all linux/soundcard.h
'N' 00-1F drivers/usb/scanner.h
'P' all linux/soundcard.h
+'P' 00-04 linux/pps.h LinuxPPS
+ <mailto:[email protected]>
'Q' all linux/soundcard.h
'R' 00-1F linux/random.h
'S' all linux/cdrom.h conflict!
diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
new file mode 100644
index 0000000..c558ec3
--- /dev/null
+++ b/Documentation/pps/pps.txt
@@ -0,0 +1,172 @@
+
+ PPS - Pulse Per Second
+ ----------------------
+
+(C) Copyright 2007 Rodolfo Giometti <[email protected]>
+
+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 consider that a PPS source is
+not always connected with a GPS data source.
+
+So your programs should check if the GPS data source (the serial port
+for instance) is a PPS source too, otherwise they should provide the
+possibility to open another device as PPS source.
+
+In LinuxPPS the PPS sources are simply char devices usually mapped
+into files /dev/pps0, /dev/pps1, etc..
+
+
+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 pps_ktimer_info = {
+ .name = "ktimer",
+ .path = "",
+ .mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
+ PPS_ECHOASSERT | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC,
+ .echo = pps_ktimer_echo,
+ .owner = THIS_MODULE,
+ };
+
+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);
+
+The pps_register_source() prototype is:
+
+ int pps_register_source(struct pps_source_info_s *info, int default_params)
+
+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).
+
+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, &ts, PPS_CAPTUREASSERT, ptr)
+
+where "ts" is the event's timestamp.
+
+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 example code.
+
+
+SYSFS support
+-------------
+
+If the SYSFS filesystem is enabled in the kernel it provides a new class:
+
+ $ ls /sys/class/pps/
+ pps0/ pps1/ pps2/
+
+Every directory is the ID of a PPS sources defined into the system and
+inside you find several files:
+
+ $ ls /sys/class/pps/pps0/
+ 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/pps0/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 /dev/pps0
+ trying PPS source "/dev/pps1"
+ found PPS source "/dev/pps1"
+ ok, found 1 source(s), now start fetching data...
+ source 0 - assert 1186592699.388832443, sequence: 364 - clear 0.000000000, sequence: 0
+ source 0 - assert 1186592700.388931295, sequence: 365 - clear 0.000000000, sequence: 0
+ source 0 - assert 1186592701.389032765, sequence: 366 - clear 0.000000000, sequence: 0
+
+Please, note that to compile userland programs you need the file timepps.h
+(see Documentation/pps/).
diff --git a/MAINTAINERS b/MAINTAINERS
index 663485b..a6dfeaa 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3373,6 +3373,13 @@ P: James Chapman
M: [email protected]
S: Maintained
+PPS SUPPORT
+P: Rodolfo Giometti
+M: [email protected]
+W: http://wiki.enneenne.com/index.php/LinuxPPS_support
+L: [email protected] (subscribers-only)
+S: Maintained
+
PREEMPTIBLE KERNEL
P: Robert Love
M: [email protected]
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 59f33fa..473fa6f 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/gpio/Kconfig"
source "drivers/w1/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 2735bde..2d46028 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -66,6 +66,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_POWER_SUPPLY) += power/
obj-$(CONFIG_HWMON) += hwmon/
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 0000000..cc2eb8e
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,33 @@
+#
+# PPS support configuration
+#
+
+menu "PPS support"
+
+config PPS
+ tristate "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 a high-precision 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.
+
+ To compile this driver as a module, choose M here: the module
+ will be called pps_core.ko.
+
+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.
+
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 0000000..19ea582
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for the PPS core.
+#
+
+pps_core-y := pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS) := pps_core.o
+
+ccflags-$(CONFIG_PPS_DEBUG) := -DDEBUG
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 0000000..749ead7
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,322 @@
+/*
+ * kapi.c -- kernel API
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <[email protected]>
+ *
+ * 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/idr.h>
+#include <linux/fs.h>
+#include <linux/pps.h>
+
+/*
+ * Global variables
+ */
+
+DEFINE_SPINLOCK(pps_idr_lock);
+DEFINE_IDR(pps_idr);
+
+/*
+ * Local functions
+ */
+
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+ ts->nsec += offset->nsec;
+ while (ts->nsec >= NSEC_PER_SEC) {
+ ts->nsec -= NSEC_PER_SEC;
+ ts->sec++;
+ }
+ while (ts->nsec < 0) {
+ ts->nsec += NSEC_PER_SEC;
+ ts->sec--;
+ }
+ ts->sec += offset->sec;
+}
+
+/*
+ * Exported functions
+ */
+
+/* pps_get_source - find a PPS source
+ *
+ * source: the PPS source ID.
+ *
+ * This function is used to find an already registered PPS source into the
+ * system.
+ *
+ * The function returns NULL if found nothing, otherwise it returns a pointer
+ * to the PPS source data struct (the refcounter is incremented by 1).
+ */
+
+struct pps_device *pps_get_source(int source)
+{
+ struct pps_device *pps;
+ unsigned long flags;
+
+ spin_lock_irqsave(&pps_idr_lock, flags);
+
+ pps = idr_find(&pps_idr, source);
+ if (pps != NULL)
+ atomic_inc(&pps->usage);
+
+ spin_unlock_irqrestore(&pps_idr_lock, flags);
+
+ return pps;
+}
+
+/* pps_put_source - free the PPS source data
+ *
+ * pps: a pointer to the PPS source.
+ *
+ * This function is used to free a PPS data struct if its refcount is 0.
+ */
+
+void pps_put_source(struct pps_device *pps)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&pps_idr_lock, flags);
+ BUG_ON(atomic_read(&pps->usage) == 0);
+
+ if (!atomic_dec_and_test(&pps->usage)) {
+ pps = NULL;
+ goto exit;
+ }
+
+ /* No more reference to the PPS source. We can safely remove the
+ * PPS data struct.
+ */
+ idr_remove(&pps_idr, pps->id);
+
+exit:
+ spin_unlock_irqrestore(&pps_idr_lock, flags);
+ kfree(pps);
+}
+
+/* pps_register_source - add a PPS source in the system
+ *
+ * info: the PPS info struct
+ * default_params: the default PPS parameters of the new source
+ *
+ * This function is used to add a new PPS source in the system. The new
+ * source is described by info's fields and it will have, as default PPS
+ * parameters, the ones specified into default_params.
+ *
+ * The function returns, in case of success, the PPS source ID.
+ */
+
+int pps_register_source(struct pps_source_info *info, int default_params)
+{
+ struct pps_device *pps;
+ int id;
+ int err;
+
+ /* Sanity checks */
+ if ((info->mode & default_params) != default_params) {
+ printk(KERN_ERR "pps: %s: unsupported default parameters\n",
+ info->name);
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+ info->echo == NULL) {
+ printk(KERN_ERR "pps: %s: echo function is not defined\n",
+ info->name);
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+ if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+ printk(KERN_ERR "pps: %s: unspecified time format\n",
+ info->name);
+ err = -EINVAL;
+ goto pps_register_source_exit;
+ }
+
+ /* Allocate memory for the new PPS source struct */
+ pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL);
+ if (pps == NULL) {
+ err = -ENOMEM;
+ goto pps_register_source_exit;
+ }
+
+ /* Get new ID for the new PPS source */
+ if (idr_pre_get(&pps_idr, GFP_KERNEL) == 0) {
+ err = -ENOMEM;
+ goto kfree_pps;
+ }
+
+ spin_lock_irq(&pps_idr_lock);
+ err = idr_get_new(&pps_idr, pps, &id);
+ spin_unlock_irq(&pps_idr_lock);
+
+ if (err < 0)
+ goto kfree_pps;
+
+ id = id & MAX_ID_MASK;
+ if (id >= PPS_MAX_SOURCES) {
+ printk(KERN_ERR "pps: %s: too many PPS sources in the system\n",
+ info->name);
+ err = -EBUSY;
+ goto free_idr;
+ }
+
+ pps->id = id;
+ pps->params.api_version = PPS_API_VERS;
+ pps->params.mode = default_params;
+ pps->info = *info;
+
+ init_waitqueue_head(&pps->queue);
+ spin_lock_init(&pps->lock);
+ atomic_set(&pps->usage, 1);
+
+ /* Create the char device */
+ err = pps_register_cdev(pps);
+ if (err < 0) {
+ printk(KERN_ERR "pps: %s: unable to create char device\n",
+ info->name);
+ goto free_idr;
+ }
+
+ pr_info("new PPS source %s at ID %d\n", info->name, id);
+
+ return id;
+
+free_idr:
+ spin_lock_irq(&pps_idr_lock);
+ idr_remove(&pps_idr, id);
+ spin_unlock_irq(&pps_idr_lock);
+
+kfree_pps:
+ kfree(pps);
+
+pps_register_source_exit:
+ printk(KERN_ERR "pps: %s: unable to register source\n", info->name);
+
+ return err;
+}
+EXPORT_SYMBOL(pps_register_source);
+
+/* pps_unregister_source - remove a PPS source from the system
+ *
+ * source: the PPS source ID
+ *
+ * This function is used to remove a previously registered PPS source from
+ * the system.
+ */
+
+void pps_unregister_source(int source)
+{
+ struct pps_device *pps;
+
+ spin_lock_irq(&pps_idr_lock);
+ pps = idr_find(&pps_idr, source);
+
+ if (!pps) {
+ BUG();
+ spin_unlock_irq(&pps_idr_lock);
+ return;
+ }
+ spin_unlock_irq(&pps_idr_lock);
+
+ pps_unregister_cdev(pps);
+ pps_put_source(pps);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+
+/* pps_event - register a PPS event into the system
+ *
+ * source: the PPS source ID
+ * ts: the event timestamp
+ * event: the event type
+ * data: userdef pointer
+ *
+ * This function is used by each PPS client in order to register a new
+ * PPS event into the system (it's usually called inside an IRQ handler).
+ *
+ * If an echo function is associated with the PPS source it will be called
+ * as:
+ * pps->info.echo(source, event, data);
+ */
+
+void pps_event(int source, struct pps_ktime *ts, int event, void *data)
+{
+ struct pps_device *pps;
+ unsigned long flags;
+
+ if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+ printk(KERN_ERR "pps: unknown event (%x) for source %d\n",
+ event, source);
+ return;
+ }
+
+ pps = pps_get_source(source);
+ if (!pps)
+ return;
+
+ pr_debug("PPS event on source %d at %llu.%06u\n",
+ pps->id, (unsigned long long) ts->sec, ts->nsec);
+
+ spin_lock_irqsave(&pps->lock, flags);
+
+ /* Must call the echo function? */
+ if ((pps->params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+ pps->info.echo(source, event, data);
+
+ /* Check the event */
+ pps->current_mode = pps->params.mode;
+ if (event & PPS_CAPTUREASSERT) {
+ /* We have to add an offset? */
+ if (pps->params.mode & PPS_OFFSETASSERT)
+ pps_add_offset(ts, &pps->params.assert_off_tu);
+
+ /* Save the time stamp */
+ pps->assert_tu = *ts;
+ pps->assert_sequence++;
+ pr_debug("capture assert seq #%u for source %d\n",
+ pps->assert_sequence, source);
+ }
+ if (event & PPS_CAPTURECLEAR) {
+ /* We have to add an offset? */
+ if (pps->params.mode & PPS_OFFSETCLEAR)
+ pps_add_offset(ts, &pps->params.clear_off_tu);
+
+ /* Save the time stamp */
+ pps->clear_tu = *ts;
+ pps->clear_sequence++;
+ pr_debug("capture clear seq #%u for source %d\n",
+ pps->clear_sequence, source);
+ }
+
+ pps->go = ~0;
+ wake_up_interruptible(&pps->queue);
+
+ kill_fasync(&pps->async_queue, SIGIO, POLL_IN);
+
+ spin_unlock_irqrestore(&pps->lock, flags);
+
+ /* Now we can release the PPS source for (possible) deregistration */
+ pps_put_source(pps);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 0000000..ceff736
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,335 @@
+/*
+ * pps.c -- Main PPS support file
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <[email protected]>
+ *
+ * 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/uaccess.h>
+#include <linux/idr.h>
+#include <linux/cdev.h>
+#include <linux/poll.h>
+#include <linux/pps.h>
+
+/*
+ * Local variables
+ */
+
+static dev_t pps_devt;
+static struct class *pps_class;
+
+/*
+ * Char device methods
+ */
+
+static unsigned int pps_cdev_poll(struct file *file, poll_table *wait)
+{
+ struct pps_device *pps = file->private_data;
+
+ poll_wait(file, &pps->queue, wait);
+
+ return POLLIN | POLLRDNORM;
+}
+
+static int pps_cdev_fasync(int fd, struct file *file, int on)
+{
+ struct pps_device *pps = file->private_data;
+ return fasync_helper(fd, file, on, &pps->async_queue);
+}
+
+static int pps_cdev_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct pps_device *pps = file->private_data;
+ struct pps_kparams params;
+ struct pps_fdata fdata;
+ unsigned long ticks;
+ void __user *uarg = (void __user *) arg;
+ int __user *iuarg = (int __user *) arg;
+ int err;
+
+ switch (cmd) {
+ case PPS_CHECK:
+
+ /* This does nothing but signal we are a PPS source... */
+
+ return 0;
+
+ case PPS_GETPARAMS:
+ pr_debug("PPS_GETPARAMS: source %d\n", pps->id);
+
+ /* Sanity checks */
+ if (!uarg)
+ return -EINVAL;
+
+ /* Return current parameters */
+ err = copy_to_user(uarg, &pps->params,
+ sizeof(struct pps_kparams));
+ if (err)
+ return -EFAULT;
+
+ break;
+
+ case PPS_SETPARAMS:
+ pr_debug("PPS_SETPARAMS: source %d\n", pps->id);
+
+ /* Check the capabilities */
+ if (!capable(CAP_SYS_TIME))
+ return -EPERM;
+
+ /* Sanity checks */
+ if (!uarg)
+ return -EINVAL;
+ err = copy_from_user(¶ms, uarg, sizeof(struct pps_kparams));
+ if (err)
+ return -EFAULT;
+ if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
+ pr_debug("capture mode unspecified (%x)\n",
+ params.mode);
+ return -EINVAL;
+ }
+
+ /* Check for supported capabilities */
+ if ((params.mode & ~pps->info.mode) != 0) {
+ pr_debug("unsupported capabilities (%x)\n",
+ params.mode);
+ return -EINVAL;
+ }
+
+ spin_lock_irq(&pps->lock);
+
+ /* Save the new parameters */
+ pps->params = params;
+
+ /* 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 (%x)\n",
+ params.mode);
+ pps->params.mode |= PPS_TSFMT_TSPEC;
+ }
+ if (pps->info.mode & PPS_CANWAIT)
+ pps->params.mode |= PPS_CANWAIT;
+ pps->params.api_version = PPS_API_VERS;
+
+ spin_unlock_irq(&pps->lock);
+
+ break;
+
+ case PPS_GETCAP:
+ pr_debug("PPS_GETCAP: source %d\n", pps->id);
+
+ /* Sanity checks */
+ if (!uarg)
+ return -EINVAL;
+
+ err = put_user(pps->info.mode, iuarg);
+ if (err)
+ return -EFAULT;
+
+ break;
+
+ case PPS_FETCH:
+ pr_debug("PPS_FETCH: source %d\n", pps->id);
+
+ if (!uarg)
+ return -EINVAL;
+ err = copy_from_user(&fdata, uarg, sizeof(struct pps_fdata));
+ if (err)
+ return -EFAULT;
+
+ pps->go = 0;
+
+ /* Manage the timeout */
+ if (fdata.timeout.flags & PPS_TIME_INVALID)
+ err = wait_event_interruptible(pps->queue, pps->go);
+ else {
+ pr_debug("timeout %lld.%09d\n",
+ (long long) fdata.timeout.sec,
+ fdata.timeout.nsec);
+ ticks = fdata.timeout.sec * HZ;
+ ticks += fdata.timeout.nsec / (NSEC_PER_SEC / HZ);
+
+ if (ticks != 0) {
+ err = wait_event_interruptible_timeout(
+ pps->queue, pps->go, ticks);
+ if (err == 0)
+ return -ETIMEDOUT;
+ }
+ }
+
+ /* Check for pending signals */
+ if (err == -ERESTARTSYS) {
+ pr_debug("pending signal caught\n");
+ return -EINTR;
+ }
+
+ /* Return the fetched timestamp */
+ spin_lock_irq(&pps->lock);
+
+ fdata.info.assert_sequence = pps->assert_sequence;
+ fdata.info.clear_sequence = pps->clear_sequence;
+ fdata.info.assert_tu = pps->assert_tu;
+ fdata.info.clear_tu = pps->clear_tu;
+ fdata.info.current_mode = pps->current_mode;
+
+ spin_unlock_irq(&pps->lock);
+
+ err = copy_to_user(uarg, &fdata, sizeof(struct pps_fdata));
+ if (err)
+ return -EFAULT;
+
+ break;
+
+ default:
+ return -ENOTTY;
+ break;
+ }
+
+ return 0;
+}
+
+static int pps_cdev_open(struct inode *inode, struct file *file)
+{
+ struct pps_device *pps = container_of(inode->i_cdev,
+ struct pps_device, cdev);
+ int found;
+
+ found = pps_get_source(pps->id) != 0;
+ if (!found)
+ return -ENODEV;
+
+ file->private_data = pps;
+
+ return 0;
+}
+
+static int pps_cdev_release(struct inode *inode, struct file *file)
+{
+ struct pps_device *pps = file->private_data;
+
+ /* Free the PPS source and wake up (possible) deregistration */
+ pps_put_source(pps);
+
+ return 0;
+}
+
+/*
+ * Char device stuff
+ */
+
+static const struct file_operations pps_cdev_fops = {
+ .owner = THIS_MODULE,
+ .llseek = no_llseek,
+ .poll = pps_cdev_poll,
+ .fasync = pps_cdev_fasync,
+ .ioctl = pps_cdev_ioctl,
+ .open = pps_cdev_open,
+ .release = pps_cdev_release,
+};
+
+int pps_register_cdev(struct pps_device *pps)
+{
+ int err;
+
+ pps->devno = MKDEV(MAJOR(pps_devt), pps->id);
+ cdev_init(&pps->cdev, &pps_cdev_fops);
+ pps->cdev.owner = pps->info.owner;
+
+ err = cdev_add(&pps->cdev, pps->devno, 1);
+ if (err) {
+ printk(KERN_ERR "pps: %s: failed to add char device %d:%d\n",
+ pps->info.name, MAJOR(pps_devt), pps->id);
+ return err;
+ }
+ pps->dev = device_create(pps_class, pps->info.dev, pps->devno, NULL,
+ "pps%d", pps->id);
+ if (err)
+ goto del_cdev;
+ dev_set_drvdata(pps->dev, pps);
+
+ pr_debug("source %s got cdev (%d:%d)\n", pps->info.name,
+ MAJOR(pps_devt), pps->id);
+
+ return 0;
+
+del_cdev:
+ cdev_del(&pps->cdev);
+
+ return err;
+}
+
+void pps_unregister_cdev(struct pps_device *pps)
+{
+ device_destroy(pps_class, pps->devno);
+ cdev_del(&pps->cdev);
+}
+
+/*
+ * Module stuff
+ */
+
+static void __exit pps_exit(void)
+{
+ class_destroy(pps_class);
+
+ if (pps_devt)
+ unregister_chrdev_region(pps_devt, PPS_MAX_SOURCES);
+
+ pr_info("LinuxPPS API ver. %d removed\n", PPS_API_VERS);
+}
+
+static int __init pps_init(void)
+{
+ int err;
+
+ pps_class = class_create(THIS_MODULE, "pps");
+ if (!pps_class) {
+ printk(KERN_ERR "pps: failed to allocate class\n");
+ return -ENOMEM;
+ }
+ pps_class->dev_attrs = pps_attrs;
+
+ err = alloc_chrdev_region(&pps_devt, 0, PPS_MAX_SOURCES, "pps");
+ if (err < 0) {
+ printk(KERN_ERR "pps: failed to allocate char device region\n");
+ goto remove_class;
+ }
+
+ pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS);
+ pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+ "<[email protected]>\n", PPS_VERSION);
+
+ return 0;
+
+remove_class:
+ class_destroy(pps_class);
+
+ return err;
+}
+
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <[email protected]>");
+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..99528a8
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,104 @@
+/*
+ * sysfs.c -- sysfs support
+ *
+ *
+ * Copyright (C) 2007 Rodolfo Giometti <[email protected]>
+ *
+ * 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>
+
+/*
+ * Attribute functions
+ */
+
+static ssize_t pps_show_assert(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ if (!(pps->info.mode & PPS_CAPTUREASSERT))
+ return 0;
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ (long long) pps->assert_tu.sec, pps->assert_tu.nsec,
+ pps->assert_sequence);
+}
+DEVICE_ATTR(assert, S_IRUGO, pps_show_assert, NULL);
+
+static ssize_t pps_show_clear(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ if (!(pps->info.mode & PPS_CAPTURECLEAR))
+ return 0;
+
+ return sprintf(buf, "%lld.%09d#%d\n",
+ (long long) pps->clear_tu.sec, pps->clear_tu.nsec,
+ pps->clear_sequence);
+}
+DEVICE_ATTR(clear, S_IRUGO, pps_show_clear, NULL);
+
+static ssize_t pps_show_mode(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ return sprintf(buf, "%4x\n", pps->info.mode);
+}
+DEVICE_ATTR(mode, S_IRUGO, pps_show_mode, NULL);
+
+static ssize_t pps_show_echo(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ return sprintf(buf, "%d\n", !!pps->info.echo);
+}
+DEVICE_ATTR(echo, S_IRUGO, pps_show_echo, NULL);
+
+static ssize_t pps_show_name(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ return sprintf(buf, "%s\n", pps->info.name);
+}
+DEVICE_ATTR(name, S_IRUGO, pps_show_name, NULL);
+
+static ssize_t pps_show_path(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pps_device *pps = dev_get_drvdata(dev);
+
+ return sprintf(buf, "%s\n", pps->info.path);
+}
+DEVICE_ATTR(path, S_IRUGO, pps_show_path, NULL);
+
+struct device_attribute pps_attrs[] = {
+ __ATTR(assert, S_IRUGO, pps_show_assert, NULL),
+ __ATTR(clear, S_IRUGO, pps_show_clear, NULL),
+ __ATTR(mode, S_IRUGO, pps_show_mode, NULL),
+ __ATTR(echo, S_IRUGO, pps_show_echo, NULL),
+ __ATTR(name, S_IRUGO, pps_show_name, NULL),
+ __ATTR(path, S_IRUGO, pps_show_path, NULL),
+ __ATTR_NULL,
+};
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 7d97067..f6bc168 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -303,6 +303,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/pps.h b/include/linux/pps.h
new file mode 100644
index 0000000..53e171c
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,202 @@
+/*
+ * pps.h -- PPS API kernel header.
+ *
+ *
+ * Copyright (C) 2005-2007 Rodolfo Giometti <[email protected]>
+ *
+ * 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_
+
+#define PPS_VERSION "5.3.1"
+#define PPS_MAX_SOURCES 16 /* should be enough... */
+
+/* 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>
+#include <sys/ioctl.h>
+#else
+#include <linux/time.h>
+#endif
+
+#define PPS_API_VERS_1 1
+#define PPS_API_VERS PPS_API_VERS_1 /* we use API version 1 */
+#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 {
+ __s64 sec;
+ __s32 nsec;
+ __u32 flags;
+};
+#define PPS_TIME_INVALID (1<<0) /* used to specify timeout==NULL */
+
+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!
+ */
+
+struct pps_fdata {
+ struct pps_kinfo info;
+ struct pps_ktime timeout;
+};
+
+#include <linux/ioctl.h>
+
+#define PPS_CHECK _IO('P', 0)
+#define PPS_GETPARAMS _IOR('P', 1, struct pps_kparams *)
+#define PPS_SETPARAMS _IOW('P', 2, struct pps_kparams *)
+#define PPS_GETCAP _IOR('P', 3, int *)
+#define PPS_FETCH _IOWR('P', 4, struct pps_fdata *)
+
+#ifdef __KERNEL__
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+
+/*
+ * Global defines
+ */
+
+/* The specific PPS source info */
+struct pps_source_info {
+ 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 */
+
+ struct module *owner;
+ struct device *dev;
+};
+
+/* The main struct */
+struct pps_device {
+ struct pps_source_info 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 */
+
+ unsigned int id; /* PPS source unique ID */
+ struct cdev cdev;
+ struct device *dev;
+ int devno;
+ struct fasync_struct *async_queue; /* fasync method */
+ spinlock_t lock;
+
+ atomic_t usage; /* usage count */
+};
+
+/*
+ * Global variables
+ */
+
+extern spinlock_t pps_idr_lock;
+extern struct idr pps_idr;
+
+extern struct device_attribute pps_attrs[];
+
+/*
+ * Exported functions
+ */
+
+struct pps_device *pps_get_source(int source);
+extern void pps_put_source(struct pps_device *pps);
+extern int pps_register_source(struct pps_source_info *info,
+ int default_params);
+extern void pps_unregister_source(int source);
+extern int pps_register_cdev(struct pps_device *pps);
+extern void pps_unregister_cdev(struct pps_device *pps);
+extern void pps_event(int source, struct pps_ktime *ts, int event, void *data);
+
+#endif /* __KERNEL__ */
+
+#endif /* _PPS_H_ */
--
1.5.4.3
Add a new line discipline for "pulse per second" devices connected to
a serial port.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
include/linux/tty.h | 3 ++-
1 files changed, 2 insertions(+), 1 deletions(-)
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 826d695..1857db2 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -24,7 +24,7 @@
*/
#define NR_UNIX98_PTY_DEFAULT 4096 /* Default maximum for Unix98 ptys */
#define NR_UNIX98_PTY_MAX (1 << MINORBITS) /* Absolute limit */
-#define NR_LDISCS 18
+#define NR_LDISCS 19
/* line disciplines */
#define N_TTY 0
@@ -46,6 +46,7 @@
#define N_HCI 15 /* Bluetooth HCI UART */
#define N_GIGASET_M101 16 /* Siemens Gigaset M101 serial DECT adapter */
#define N_SLCAN 17 /* Serial / USB serial CAN Adaptors */
+#define N_PPS 18 /* Pulse per Second */
/*
* This character is the same as _POSIX_VDISABLE: it cannot be used as
--
1.5.4.3
Adds support, by using the PPS line discipline, for the PPS sources
connected with the CD (Carrier Detect) pin of a serial port.
Signed-off-by: Rodolfo Giometti <[email protected]>
---
drivers/pps/clients/Kconfig | 7 ++
drivers/pps/clients/Makefile | 1 +
drivers/pps/clients/pps-ldisc.c | 154 +++++++++++++++++++++++++++++++++++++++
drivers/serial/8250.c | 13 +++
include/linux/serial_core.h | 10 ++-
5 files changed, 184 insertions(+), 1 deletions(-)
create mode 100644 drivers/pps/clients/pps-ldisc.c
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
index 60b83be..487c1c8 100644
--- a/drivers/pps/clients/Kconfig
+++ b/drivers/pps/clients/Kconfig
@@ -15,4 +15,11 @@ config PPS_CLIENT_KTIMER
This driver can also be built as a module. If so, the module
will be called ktimer.ko.
+config PPS_CLIENT_LDISC
+ tristate "PPS line discipline"
+ depends on PPS
+ help
+ If you say yes here you get support for a PPS source connected
+ with the CD (Carrier Detect) pin of your serial port.
+
endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
index f3c1e39..9f5b988 100644
--- a/drivers/pps/clients/Makefile
+++ b/drivers/pps/clients/Makefile
@@ -3,6 +3,7 @@
#
obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
+obj-$(CONFIG_PPS_CLIENT_LDISC) += pps-ldisc.o
ifeq ($(CONFIG_PPS_DEBUG),y)
EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/pps/clients/pps-ldisc.c b/drivers/pps/clients/pps-ldisc.c
new file mode 100644
index 0000000..f1efa26
--- /dev/null
+++ b/drivers/pps/clients/pps-ldisc.c
@@ -0,0 +1,154 @@
+/*
+ * pps-ldisc.c -- PPS line discipline
+ *
+ *
+ * Copyright (C) 2008 Rodolfo Giometti <[email protected]>
+ *
+ * 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/module.h>
+#include <linux/serial_core.h>
+#include <linux/tty.h>
+#include <linux/pps.h>
+
+#define PPS_TTY_MAGIC 0x0001
+
+static void pps_tty_dcd_change(struct uart_port *port, unsigned int status,
+ struct timespec *ts)
+{
+ int id = (int) port->info->port.tty->disc_data;
+ struct timespec __ts;
+ struct pps_ktime pps_ts;
+
+ /* First of all we get the time stamp... */
+ getnstimeofday(&__ts);
+
+ /* Does caller give us a timestamp? */
+ if (ts) { /* Yes. Let's use it! */
+ pps_ts.sec = ts->tv_sec;
+ pps_ts.nsec = ts->tv_nsec;
+ } else { /* No. Do it ourself! */
+ pps_ts.sec = __ts.tv_sec;
+ pps_ts.nsec = __ts.tv_nsec;
+ }
+
+ /* Now do the PPS event report */
+ pps_event(id, &pps_ts, status ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR,
+ port);
+
+ pr_debug("[STDev] PPS %s at %lu on source #%d\n",
+ status ? "assert" : "clear", jiffies, id);
+}
+
+static int pps_tty_open(struct tty_struct *tty)
+{
+ struct pps_source_info info;
+ struct tty_driver *drv = tty->driver;
+ int index = tty->index + drv->name_base;
+ int ret;
+
+ info.owner = THIS_MODULE;
+ info.dev = NULL;
+ snprintf(info.name, PPS_MAX_NAME_LEN, "%s%d", drv->driver_name, index);
+ snprintf(info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", drv->name, index);
+ info.mode = PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+ PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+ ret = pps_register_source(&info, PPS_CAPTUREBOTH | \
+ PPS_OFFSETASSERT | PPS_OFFSETCLEAR);
+ if (ret < 0) {
+ pr_err("cannot register PPS source \"%s\"\n", info.path);
+ return ret;
+ }
+ tty->disc_data = (void *) ret;
+
+ /* Should open N_TTY ldisc too */
+ ret = n_tty_open(tty);
+ if (ret < 0)
+ pps_unregister_source((int) tty->disc_data);
+
+ pr_info("PPS source #%d \"%s\" added\n", ret, info.path);
+
+ return 0;
+}
+
+static void pps_tty_close(struct tty_struct *tty)
+{
+ int id = (int) tty->disc_data;
+
+ pps_unregister_source(id);
+ n_tty_close(tty);
+
+ pr_info("PPS source #%d removed\n", id);
+}
+
+struct tty_ldisc_ops pps_ldisc_ops = {
+ .magic = PPS_TTY_MAGIC,
+ .name = "pps_tty",
+ .dcd_change = pps_tty_dcd_change,
+ .open = pps_tty_open,
+ .close = pps_tty_close,
+
+ /* Now we should use N_TTY ldisc methods in order to have
+ * normal tty behaviour
+ */
+ .flush_buffer = n_tty_flush_buffer,
+ .chars_in_buffer = n_tty_chars_in_buffer,
+ .read = n_tty_read,
+ .write = n_tty_write,
+ .ioctl = n_tty_ioctl,
+ .set_termios = n_tty_set_termios,
+ .poll = n_tty_poll,
+ .receive_buf = n_tty_receive_buf,
+ .write_wakeup = n_tty_write_wakeup
+};
+
+/*
+ * Module stuff
+ */
+
+static int __init pps_tty_init(void)
+{
+ int err;
+
+ err = tty_register_ldisc(N_PPS, &pps_ldisc_ops);
+ if (err)
+ pr_err("can't register PPS line discipline\n");
+ else
+ pr_info("PPS line discipline registered\n");
+
+ return err;
+}
+
+static void __exit pps_tty_cleanup(void)
+{
+ int err;
+
+ err = tty_unregister_ldisc(N_PPS);
+ if (err)
+ pr_err("can't unregister PPS line discipline\n");
+ else
+ pr_info("PPS line discipline removed\n");
+}
+
+module_init(pps_tty_init);
+module_exit(pps_tty_cleanup);
+
+MODULE_ALIAS_LDISC(N_PPS);
+MODULE_AUTHOR("Rodolfo Giometti <[email protected]>");
+MODULE_DESCRIPTION("PPS TTY device driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 342e12f..1759d87 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2247,6 +2247,18 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
}
static void
+serial8250_set_ldisc(struct uart_port *port)
+{
+ int line = port->line;
+
+ if (line >= port->info->port.tty->driver->num)
+ return;
+
+ if (port->info->port.tty->ldisc.ops->num == N_PPS)
+ serial8250_enable_ms(port);
+}
+
+static void
serial8250_pm(struct uart_port *port, unsigned int state,
unsigned int oldstate)
{
@@ -2450,6 +2462,7 @@ static struct uart_ops serial8250_pops = {
.startup = serial8250_startup,
.shutdown = serial8250_shutdown,
.set_termios = serial8250_set_termios,
+ .set_ldisc = serial8250_set_ldisc,
.pm = serial8250_pm,
.type = serial8250_type,
.release_port = serial8250_release_port,
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 3b2f6c0..1aa894c 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -488,9 +488,13 @@ static inline void
uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
+ struct tty_ldisc *ld = tty_ldisc_ref(info->port.tty);
+ struct timespec ts;
- port->icount.dcd++;
+ if (ld->ops->dcd_change)
+ getnstimeofday(&ts);
+ port->icount.dcd++;
#ifdef CONFIG_HARD_PPS
if ((port->flags & UPF_HARDPPS_CD) && status)
hardpps();
@@ -502,6 +506,10 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
else if (info->port.tty)
tty_hangup(info->port.tty);
}
+
+ if (ld->ops->dcd_change)
+ ld->ops->dcd_change(port, status, &ts);
+ tty_ldisc_deref(ld);
}
/**
--
1.5.4.3
> + * void (*dcd_change)(struct uart_port *port, unsigned int status,
> + * struct timespec *ts)
> + *
> + * Tells the discipline that the DCD pin has changed its status and
> + * the relative timestamp. Pointer ts can be NULL.
> */
uart_port is a specific property of a few random types of interface, pass
a tty struct up. Otherwise looks fine. Might one day expand it to a more
generic change type and pass info on what changed but thats a future
mystery.
On Tue, 19 Aug 2008 23:50:09 +0200
Rodolfo Giometti <[email protected]> wrote:
> Add a new line discipline for "pulse per second" devices connected to
> a serial port.
>
> Signed-off-by: Rodolfo Giometti <[email protected]
Ack this and I'll push it upstream anyway so there is a stable number even
if this doesn't all get upstream for a while.
Acked-by: Alan Cox <[email protected]>
> +static void pps_tty_dcd_change(struct uart_port *port, unsigned int status,
> + struct timespec *ts)
> +{
> + int id = (int) port->info->port.tty->disc_data;
See you really do want to pass struct tty * upwards anyway 8)
Rest of this looks good. Maybe pps ldisc belongs in the n_tty file in the
end but again that can be twiddled with after the merge.
On Tue, 19 Aug 2008 23:50:08 +0200
Rodolfo Giometti <[email protected]> wrote:
> Signed-off-by: Rodolfo Giometti <[email protected]>
> ---
> drivers/char/n_tty.c | 54 +++++++++++++++++++++++++++++--------------------
> include/linux/tty.h | 16 ++++++++++++++
> 2 files changed, 48 insertions(+), 22 deletions(-)
Renames are really not part of the same change set but very sensible so
no objection. EXPORT_SYMBOL_GPL please - pps is (with permission)
sticking its nose into the innards of n_tty. Those are not good general
interfaces however.
With the small changes noted I'm happy for the tty stuff to go upstream.
On Tue, Aug 19, 2008 at 10:53:22PM +0100, Alan Cox wrote:
> > + * void (*dcd_change)(struct uart_port *port, unsigned int status,
> > + * struct timespec *ts)
> > + *
> > + * Tells the discipline that the DCD pin has changed its status and
> > + * the relative timestamp. Pointer ts can be NULL.
> > */
>
> uart_port is a specific property of a few random types of interface, pass
> a tty struct up. Otherwise looks fine. Might one day expand it to a more
> generic change type and pass info on what changed but thats a future
> mystery.
How can I get the struct uart_port pointer starting from struct
tty_struct one? I need it in order to know which is the IRQ line of a
single port.
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti
On Wed, 20 Aug 2008 00:49:31 +0200
Rodolfo Giometti <[email protected]> wrote:
> On Tue, Aug 19, 2008 at 10:53:22PM +0100, Alan Cox wrote:
> > > + * void (*dcd_change)(struct uart_port *port, unsigned int status,
> > > + * struct timespec *ts)
> > > + *
> > > + * Tells the discipline that the DCD pin has changed its status and
> > > + * the relative timestamp. Pointer ts can be NULL.
> > > */
> >
> > uart_port is a specific property of a few random types of interface, pass
> > a tty struct up. Otherwise looks fine. Might one day expand it to a more
> > generic change type and pass info on what changed but thats a future
> > mystery.
>
> How can I get the struct uart_port pointer starting from struct
> tty_struct one?
A tty may not even have a uart structure. Why do you need to know the
interrupt (if such a concept even exists for the given tty) ?
Alan
On Tue, Aug 19, 2008 at 11:38:57PM +0100, Alan Cox wrote:
> On Wed, 20 Aug 2008 00:49:31 +0200
> Rodolfo Giometti <[email protected]> wrote:
>
> > On Tue, Aug 19, 2008 at 10:53:22PM +0100, Alan Cox wrote:
> > > > + * void (*dcd_change)(struct uart_port *port, unsigned int status,
> > > > + * struct timespec *ts)
> > > > + *
> > > > + * Tells the discipline that the DCD pin has changed its status and
> > > > + * the relative timestamp. Pointer ts can be NULL.
> > > > */
> > >
> > > uart_port is a specific property of a few random types of interface, pass
> > > a tty struct up. Otherwise looks fine. Might one day expand it to a more
> > > generic change type and pass info on what changed but thats a future
> > > mystery.
> >
> > How can I get the struct uart_port pointer starting from struct
> > tty_struct one?
>
> A tty may not even have a uart structure. Why do you need to know the
> interrupt (if such a concept even exists for the given tty) ?
If you look at patch 9
(0009-PPS-low-level-IRQ-timestamps-recording.patch) you can see that
we add a (dirty?) trick to improve PPS precision a lot: we record all
IRQ timestamps into static array and then we return those values
instead of ones passed by dcd_change()...
Maybe I can solve the problem defining dcd_change() as follow:
void (*dcd_change)(struct tty_struct *tty, unsigned int status,
void *data)
and then passing the timestamp or struct uart_port pointer?
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti
Rodolfo Giometti wrote:
> 'P' all linux/soundcard.h
> +'P' 00-04 linux/pps.h LinuxPPS
> + <mailto:[email protected]>
This represents a reservation conflict even if it doesn't represent an
actual conflict. If it is a reservation conflict only, please adjust
the range reserved for soundcards (and verify with the sound maintainers
that it's okay to do so); if it's an actual conflict please reassign.
-hpa
On Wed, Aug 20, 2008 at 01:05:23AM +0200, Rodolfo Giometti wrote:
> Maybe I can solve the problem defining dcd_change() as follow:
>
> void (*dcd_change)(struct tty_struct *tty, unsigned int status,
> void *data)
>
> and then passing the timestamp or struct uart_port pointer?
After sleeping this night :) I think is better defing the
uart_handle_dcd_change() into serial_core.h as follow:
uart_handle_dcd_change(struct uart_port *port, unsigned int status)
{
struct uart_info *info = port->info;
struct tty_ldisc *ld = tty_ldisc_ref(info->port.tty);
struct timespec ts;
if (ld->ops->dcd_change)
#ifdef CONFIG_PPS_IRQ_EVENTS
ts = pps_irq_ts[port->irq];
#else
getnstimeofday(&ts);
#endif
port->icount.dcd++;
#ifdef CONFIG_HARD_PPS
if ((port->flags & UPF_HARDPPS_CD) && status)
hardpps();
#endif
if (info->flags & UIF_CHECK_CD) {
if (status)
wake_up_interruptible(&info->port.open_wait);
else if (info->port.tty)
tty_hangup(info->port.tty);
}
if (ld->ops->dcd_change)
ld->ops->dcd_change(info->port.tty, status, &ts);
tty_ldisc_deref(ld);
}
This completely hides the (dirty) trick to the PPS clients and allow
using struct tty_struct as first parameter.
Is that acceptable?
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti
On Tue, Aug 19, 2008 at 04:22:54PM -0700, H. Peter Anvin wrote:
> Rodolfo Giometti wrote:
>> 'P' all linux/soundcard.h
>> +'P' 00-04 linux/pps.h LinuxPPS
>> + <mailto:[email protected]>
>
> This represents a reservation conflict even if it doesn't represent an
> actual conflict. If it is a reservation conflict only, please adjust
> the range reserved for soundcards (and verify with the sound maintainers
> that it's okay to do so); if it's an actual conflict please reassign.
I think is quicker that I reassing the codes. I'll use 'p' a0-a4 which
are free.
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti
O> #ifdef CONFIG_PPS_IRQ_EVENTS
> ts = pps_irq_ts[port->irq];
> #else
That bit won't work very shortly - IRQ numbers are going sparse not a
single simple NR_IRQ array.
> This completely hides the (dirty) trick to the PPS clients and allow
> using struct tty_struct as first parameter.
Can we get the basics right first - drop the IRQ_EVENTS and HARDPPS
hackery out of the patchset and the core code then looks quite clean.
After that is sorted/merged we can come back to working out the best way
to improve the IRQ and HARDPPS hacks.
Alan
* Rodolfo Giometti <[email protected]> wrote:
> Add low level IRQ timestamps recording for x86 (32 and 64 bits)
> platforms and enable UART clients in order to use it.
>
> This improves PPS precision. :)
>
> Signed-off-by: Rodolfo Giometti <[email protected]>
> ---
> arch/x86/kernel/irq_32.c | 18 ++++++++++++++++++
> arch/x86/kernel/irq_64.c | 22 ++++++++++++++++++++--
> drivers/pps/Kconfig | 12 ++++++++++++
> drivers/pps/clients/pps-ldisc.c | 18 ++++++++++++++++++
> include/linux/pps.h | 1 +
> 5 files changed, 69 insertions(+), 2 deletions(-)
hm, NACK on this line of approach. If then this instrumentation should
be done at the genirq level (kernel/irq/*.c). Also, the #ifdefs are ugly
- please hide them in include files.
Ingo
On Wed, Aug 20, 2008 at 11:11:17AM +0100, Alan Cox wrote:
> Can we get the basics right first - drop the IRQ_EVENTS and HARDPPS
> hackery out of the patchset and the core code then looks quite clean.
> After that is sorted/merged we can come back to working out the best way
> to improve the IRQ and HARDPPS hacks.
On Wed, Aug 20, 2008 at 12:31:15PM +0200, Ingo Molnar wrote:
> hm, NACK on this line of approach. If then this instrumentation should
> be done at the genirq level (kernel/irq/*.c). Also, the #ifdefs are ugly
> - please hide them in include files.
Ok, I'll propose a new patch set without the IRQ_EVENTS part (or with
this support as last patch to be easily discarted) to get kernel
inclusion, but we had to solve this issue soon since without this
trick the PPS precision is quite low.
Thanks,
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti
* Rodolfo Giometti <[email protected]> wrote:
> On Wed, Aug 20, 2008 at 11:11:17AM +0100, Alan Cox wrote:
>
> > Can we get the basics right first - drop the IRQ_EVENTS and HARDPPS
> > hackery out of the patchset and the core code then looks quite clean.
> > After that is sorted/merged we can come back to working out the best way
> > to improve the IRQ and HARDPPS hacks.
>
> On Wed, Aug 20, 2008 at 12:31:15PM +0200, Ingo Molnar wrote:
>
> > hm, NACK on this line of approach. If then this instrumentation should
> > be done at the genirq level (kernel/irq/*.c). Also, the #ifdefs are ugly
> > - please hide them in include files.
>
> Ok, I'll propose a new patch set without the IRQ_EVENTS part (or with
> this support as last patch to be easily discarted) to get kernel
> inclusion, but we had to solve this issue soon since without this
> trick the PPS precision is quite low.
well, i didnt suggest you kill that aspect of the patchset - i suggested
you change it to hook into kernel/irq/*.c instead of
arch/x86/kernel/irq*.c.
That way all other architectures will benefit from it, not just x86.
Doing an x86-only thing for such features is completely unacceptable.
Ingo
On Wed, Aug 20, 2008 at 03:48:49PM +0200, Ingo Molnar wrote:
> well, i didnt suggest you kill that aspect of the patchset - i suggested
I see, but I agree with Alan that is better to get a first working
inclusion and then working on improments. 8)
> you change it to hook into kernel/irq/*.c instead of
> arch/x86/kernel/irq*.c.
>
> That way all other architectures will benefit from it, not just x86.
> Doing an x86-only thing for such features is completely unacceptable.
I see but doing like this I can record IRQs timestamps sooner than in
kernel/irq/*.c, is that right? PPS precision is as better as sooner we
record the timestamps.
Ciao,
Rodolfo
--
GNU/Linux Solutions e-mail: [email protected]
Linux Device Driver [email protected]
Embedded Systems phone: +39 349 2432127
UNIX programming skype: rodolfo.giometti