* LinuxPPS (RESUBMIT 3): the PPS Linux implementation. @ 2008-04-10 15:15 Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 2008-04-10 15:28 ` LinuxPPS (RESUBMIT 3): the PPS Linux implementation Lennart Sorensen 0 siblings, 2 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers 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. Rodolfo -- Documentation/pps/Makefile | 2 b/Documentation/ABI/testing/sysfs-pps | 73 +++++++ b/Documentation/ioctl-number.txt | 2 b/Documentation/pps/Makefile | 27 ++ b/Documentation/pps/pps.txt | 170 +++++++++++++++++ b/Documentation/pps/ppsctl.c | 63 ++++++ b/Documentation/pps/ppsfind | 17 + b/Documentation/pps/ppstest.c | 152 +++++++++++++++ b/Documentation/pps/timepps.h | 196 +++++++++++++++++++ b/MAINTAINERS | 7 b/drivers/Kconfig | 2 b/drivers/Makefile | 1 b/drivers/char/lp.c | 61 ++++++ 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 | 115 +++++++++++ b/drivers/pps/kapi.c | 330 +++++++++++++++++++++++++++++++++ b/drivers/pps/pps.c | 335 ++++++++++++++++++++++++++++++++++ b/drivers/pps/sysfs.c | 103 ++++++++++ b/drivers/serial/8250.c | 2 b/drivers/serial/serial_core.c | 131 ++++++++++--- b/include/linux/Kbuild | 1 b/include/linux/parport.h | 13 + b/include/linux/pps.h | 203 ++++++++++++++++++++ b/include/linux/serial_core.h | 31 ++- drivers/pps/Kconfig | 2 drivers/pps/Makefile | 1 drivers/pps/clients/Kconfig | 20 ++ 30 files changed, 2083 insertions(+), 45 deletions(-) ^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 1/7] LinuxPPS core support. 2008-04-10 15:15 LinuxPPS (RESUBMIT 3): the PPS Linux implementation Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 2008-04-10 15:28 ` LinuxPPS (RESUBMIT 3): the PPS Linux implementation Lennart Sorensen 1 sibling, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti 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 <giometti@linux.it> --- Documentation/ABI/testing/sysfs-pps | 73 ++++++++ Documentation/ioctl-number.txt | 2 + Documentation/pps/pps.txt | 170 ++++++++++++++++++ MAINTAINERS | 7 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/pps/Kconfig | 33 ++++ drivers/pps/Makefile | 8 + drivers/pps/kapi.c | 330 ++++++++++++++++++++++++++++++++++ drivers/pps/pps.c | 335 +++++++++++++++++++++++++++++++++++ drivers/pps/sysfs.c | 103 +++++++++++ include/linux/Kbuild | 1 + include/linux/pps.h | 202 +++++++++++++++++++++ 13 files changed, 1267 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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 c18363b..b4c7d26 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:giometti@linux.it> '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..2b25a48 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,170 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you 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, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for 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 90dcbbc..a67d624 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3171,6 +3171,13 @@ P: James Chapman M: jchapman@katalix.com S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/drivers/Kconfig b/drivers/Kconfig index 3a0e354..0c11e5c 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 e5e394a..adc0924 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -62,6 +62,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..6c72e2e --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,330 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/spinlock.h> +#include <linux/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 + * 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, int event, void *data) +{ + struct pps_device *pps; + struct timespec __ts; + struct pps_ktime ts; + unsigned long flags; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + printk(KERN_ERR "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..a46f8f4 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,335 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/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, + "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 " + "<giometti@linux.it>\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 <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..0520f62 --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,103 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> +#include <linux/pps.h> + +/* + * 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), +}; diff --git a/include/linux/Kbuild b/include/linux/Kbuild index 9cdd12a..0dd702c 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -294,6 +294,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..83a23d2 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,202 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +#define PPS_VERSION "5.1.0" +#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, int event, void *data); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 2/7] PPS: userland header file for PPS API. 2008-04-10 15:15 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti 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 <giometti@linux.it> --- 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 <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +#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 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 3/7] PPS: documentation programs and examples. 2008-04-10 15:15 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti Here some utilities and examples about the PPS API and the LinuxPPS support. * 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 <giometti@linux.it> --- Documentation/pps/Makefile | 27 ++++++++ Documentation/pps/ppsfind | 17 +++++ Documentation/pps/ppstest.c | 151 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 195 insertions(+), 0 deletions(-) create mode 100644 Documentation/pps/Makefile create mode 100644 Documentation/pps/ppsfind create mode 100644 Documentation/pps/ppstest.c diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..af4f9b4 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section -- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section -- + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/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/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 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 4/7] PPS: LinuxPPS clients support. 2008-04-10 15:15 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti 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 <giometti@linux.it> --- drivers/pps/Kconfig | 2 + drivers/pps/Makefile | 1 + drivers/pps/clients/Kconfig | 18 +++++++ drivers/pps/clients/Makefile | 9 +++ drivers/pps/clients/ktimer.c | 114 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 144 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..5845188 --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pr_info("PPS event at %lu\n", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pr_info("echo %s %s for source %d\n", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info 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 <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 5/7] PPS: serial clients support. 2008-04-10 15:15 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 6/7] PPS: example program to enable PPS support on serial ports Rodolfo Giometti 2008-04-10 15:28 ` [PATCH 5/7] PPS: serial " Alan Cox 0 siblings, 2 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti Adds support for the PPS sources connected with the CD (Carrier Detect) pin of a serial port. Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- drivers/pps/clients/Kconfig | 10 +++ drivers/serial/8250.c | 2 + drivers/serial/serial_core.c | 131 ++++++++++++++++++++++++++++++++---------- include/linux/serial_core.h | 30 ++++++++-- 4 files changed, 136 insertions(+), 37 deletions(-) diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig index 60b83be..517c338 100644 --- a/drivers/pps/clients/Kconfig +++ b/drivers/pps/clients/Kconfig @@ -15,4 +15,14 @@ config PPS_CLIENT_KTIMER This driver can also be built as a module. If so, the module will be called ktimer.ko. +comment "UART serial support (forced off)" + depends on ! (SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y)) + +config PPS_CLIENT_UART + bool "UART serial support" + depends on SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y) + 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/serial/8250.c b/drivers/serial/8250.c index 77f7a7f..880cbeb 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2119,6 +2119,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 0f5a179..5a97e63 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -58,8 +59,7 @@ static struct lock_class_key port_lock_key; #define uart_console(port) (0) #endif -static void uart_change_speed(struct uart_state *state, - struct ktermios *old_termios); +static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios); static void uart_wait_until_sent(struct tty_struct *tty, int timeout); static void uart_change_pm(struct uart_state *state, int pm_state); @@ -130,8 +130,8 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear) spin_unlock_irqrestore(&port->lock, flags); } -#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0) -#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear) +#define uart_set_mctrl(port,set) uart_update_mctrl(port,set,0) +#define uart_clear_mctrl(port,clear) uart_update_mctrl(port,0,clear) /* * Startup the port. This will be called once per open. All calls @@ -291,7 +291,7 @@ uart_update_timeout(struct uart_port *port, unsigned int cflag, break; default: bits = 10; - break; /* CS8 */ + break; // CS8 } if (cflag & CSTOPB) @@ -372,8 +372,7 @@ uart_get_baud_rate(struct uart_port *port, struct ktermios *termios, */ termios->c_cflag &= ~CBAUD; if (old) { - baud = tty_termios_baud_rate(old); - tty_termios_encode_baud_rate(termios, baud, baud); + termios->c_cflag |= old->c_cflag & CBAUD; old = NULL; continue; } @@ -382,7 +381,7 @@ uart_get_baud_rate(struct uart_port *port, struct ktermios *termios, * As a last resort, if the quotient is zero, * default to 9600 bps */ - tty_termios_encode_baud_rate(termios, 9600, 9600); + termios->c_cflag |= B9600; } return 0; @@ -635,6 +634,63 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + state->pps_info.owner = THIS_MODULE; + state->pps_info.dev = port->dev; + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); + if (ret < 0) { + dev_err(port->dev, "cannot register PPS source \"%s\"\n", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(port->pps_source); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, state->pps_info.path); +} + +#else + +static inline int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + return 0; +} + +static inline void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + /* Nop */ +} + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -789,8 +845,7 @@ static int uart_set_info(struct uart_state *state, * We failed anyway. */ retval = -EBUSY; - /* Added to return the correct error -Ram Gupta */ - goto exit; + goto exit; // Added to return the correct error -Ram Gupta } } @@ -810,11 +865,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -1139,8 +1202,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, return ret; } -static void uart_set_termios(struct tty_struct *tty, - struct ktermios *old_termios) +static void uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios) { struct uart_state *state = tty->driver_data; unsigned long flags; @@ -1464,8 +1526,9 @@ uart_block_til_ready(struct file *filp, struct uart_state *state) */ if ((filp->f_flags & O_NONBLOCK) || (info->tty->termios->c_cflag & CLOCAL) || - (info->tty->flags & (1 << TTY_IO_ERROR))) + (info->tty->flags & (1 << TTY_IO_ERROR))) { break; + } /* * Set DTR to allow modem to know we're waiting. Do @@ -1553,8 +1616,8 @@ static struct uart_state *uart_get(struct uart_driver *drv, int line) } /* - * calls to uart_open are serialised by the BKL in - * fs/char_dev.c:chrdev_open() + * In 2.4.5, calls to uart_open are serialised by the BKL in + * linux/fs/devices.c:chrdev_open() * Note that if this fails, then uart_close() _will_ be called. * * In time, we want to scrap the "opening nonpresent ports" @@ -1684,7 +1747,8 @@ static int uart_line_info(char *buf, struct uart_driver *drv, int i) return ret + 1; } - if (capable(CAP_SYS_ADMIN)) { + if(capable(CAP_SYS_ADMIN)) + { mutex_lock(&state->mutex); pm_state = state->pm_state; if (pm_state) @@ -1711,11 +1775,11 @@ static int uart_line_info(char *buf, struct uart_driver *drv, int i) ret += sprintf(buf + ret, " oe:%d", port->icount.overrun); -#define INFOBIT(bit, str) \ +#define INFOBIT(bit,str) \ if (port->mctrl & (bit)) \ strncat(stat_buf, (str), sizeof(stat_buf) - \ strlen(stat_buf) - 2) -#define STATBIT(bit, str) \ +#define STATBIT(bit,str) \ if (status & (bit)) \ strncat(stat_buf, (str), sizeof(stat_buf) - \ strlen(stat_buf) - 2) @@ -1979,7 +2043,6 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port) if (state->info && state->info->flags & UIF_INITIALIZED) { const struct uart_ops *ops = port->ops; - int tries; state->info->flags = (state->info->flags & ~UIF_INITIALIZED) | UIF_SUSPENDED; @@ -1993,14 +2056,9 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port) /* * Wait for the transmitter to empty. */ - for (tries = 3; !ops->tx_empty(port) && tries; tries--) + while (!ops->tx_empty(port)) { msleep(10); - if (!tries) - printk(KERN_ERR "%s%s%s%d: Unable to drain " - "transmitter\n", - port->dev ? port->dev->bus_id : "", - port->dev ? ": " : "", - drv->dev_name, port->line); + } ops->shutdown(port); } @@ -2037,6 +2095,8 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port) } port->suspended = 0; + uart_change_pm(state, 0); + /* * Re-enable the console device after suspending. */ @@ -2055,7 +2115,6 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port) if (state->info && state->info->tty && termios.c_cflag == 0) termios = *state->info->tty->termios; - uart_change_pm(state, 0); port->ops->set_termios(port, &termios, NULL); console_start(port->cons); } @@ -2064,7 +2123,6 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port) const struct uart_ops *ops = port->ops; int ret; - uart_change_pm(state, 0); ops->set_mctrl(port, 0); ret = ops->startup(port); if (ret == 0) { @@ -2148,6 +2206,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2158,11 +2222,10 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, /* * Ensure that the modem control lines are de-activated. - * keep the DTR setting that is set in uart_set_options() * We probably don't need a spinlock around this, but */ spin_lock_irqsave(&port->lock, flags); - port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR); + port->ops->set_mctrl(port, 0); spin_unlock_irqrestore(&port->lock, flags); /* @@ -2405,6 +2468,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 289942f..0f8fbd4 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -166,6 +166,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -245,6 +246,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -289,7 +293,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -322,6 +327,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info pps_info; +#endif + struct mutex mutex; }; @@ -486,13 +495,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; - -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); +#ifdef CONFIG_PPS_CLIENT_UART + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n", + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 6/7] PPS: example program to enable PPS support on serial ports. 2008-04-10 15:15 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti @ 2008-04-10 15:15 ` Rodolfo Giometti 2008-04-10 15:16 ` [PATCH 7/7] PPS: parallel port clients support Rodolfo Giometti 2008-04-10 15:28 ` [PATCH 5/7] PPS: serial " Alan Cox 1 sibling, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:15 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- Documentation/pps/Makefile | 2 +- Documentation/pps/ppsctl.c | 62 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletions(-) create mode 100644 Documentation/pps/ppsctl.c diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile index af4f9b4..8ef4f47 100644 --- a/Documentation/pps/Makefile +++ b/Documentation/pps/Makefile @@ -1,4 +1,4 @@ -TARGETS = ppstest +TARGETS = ppstest ppsctl CFLAGS += -Wall -O2 -D_GNU_SOURCE CFLAGS += -I . diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c new file mode 100644 index 0000000..83fd08a --- /dev/null +++ b/Documentation/pps/ppsctl.c @@ -0,0 +1,62 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <string.h> +#include <linux/serial.h> + +void usage(char *name) +{ + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name); + + exit(EXIT_FAILURE); +} + +int main(int argc, char *argv[]) +{ + int fd; + int ret; + struct serial_struct ss; + + if (argc < 2) + usage(argv[0]); + + fd = open(argv[1], O_RDWR); + if (fd < 0) { + perror("open"); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCGSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCGSERIAL)"); + exit(EXIT_FAILURE); + } + + if (argc < 3) { /* just read PPS status */ + printf("PPS is %sabled\n", + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis"); + exit(EXIT_SUCCESS); + } + + if (argv[2][0] == 'e' || argv[2][0] == '1') + ss.flags |= ASYNC_HARDPPS_CD; + else if (argv[2][0] == 'd' || argv[2][0] == '0') + ss.flags &= ~ASYNC_HARDPPS_CD; + else { + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCSSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCSSERIAL)"); + exit(EXIT_FAILURE); + } + + return 0; +} -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 7/7] PPS: parallel port clients support. 2008-04-10 15:15 ` [PATCH 6/7] PPS: example program to enable PPS support on serial ports Rodolfo Giometti @ 2008-04-10 15:16 ` Rodolfo Giometti 0 siblings, 0 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:16 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti Adds support for the PPS sources connected with the interrupt pin of a parallel port. Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- drivers/char/lp.c | 61 +++++++++++++++++++++++++++++++++++++++++++ drivers/pps/clients/Kconfig | 10 +++++++ include/linux/parport.h | 12 ++++++++ 3 files changed, 83 insertions(+), 0 deletions(-) diff --git a/drivers/char/lp.c b/drivers/char/lp.c index 60ac642..b201fed 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -746,6 +746,27 @@ static struct console lpcons = { #endif /* console on line printer */ +/* Support for PPS signal on the line printer */ + +#ifdef CONFIG_PPS_CLIENT_LP + +static void lp_pps_echo(int source, int event, void *data) +{ + struct parport *port = data; + unsigned char status = parport_read_status(port); + + /* echo event via SEL bit */ + parport_write_control(port, + parport_read_control(port) | PARPORT_CONTROL_SELECT); + + /* signal no event */ + if ((status & PARPORT_STATUS_ACK) != 0) + parport_write_control(port, + parport_read_control(port) & ~PARPORT_CONTROL_SELECT); +} + +#endif + /* --- initialisation code ------------------------------------- */ static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC }; @@ -816,6 +837,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; } @@ -858,6 +911,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 517c338..09ba5c3 100644 --- a/drivers/pps/clients/Kconfig +++ b/drivers/pps/clients/Kconfig @@ -25,4 +25,14 @@ config PPS_CLIENT_UART 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 d1ad546..501a9dc 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 <asm/system.h> #include <asm/ptrace.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,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode); /* Lowlevel drivers _can_ call this support function to handle irqs. */ static inline void parport_generic_irq(struct parport *port) { +#ifdef CONFIG_PPS_CLIENT_LP + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); +#endif + parport_ieee1284_interrupt (port); read_lock(&port->cad_lock); if (port->cad && port->cad->irq_func) -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 15:15 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 6/7] PPS: example program to enable PPS support on serial ports Rodolfo Giometti @ 2008-04-10 15:28 ` Alan Cox 2008-04-10 15:36 ` Rodolfo Giometti 1 sibling, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-04-10 15:28 UTC (permalink / raw) To: Rodolfo Giometti Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti On Thu, 10 Apr 2008 17:15:58 +0200 Rodolfo Giometti <giometti@linux.it> wrote: > Adds support for the PPS sources connected with the CD (Carrier > Detect) pin of a serial port. Ok why does this need to hack the driver layer ? > -static void uart_change_speed(struct uart_state *state, > - struct ktermios *old_termios); > +static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios); NAK. Please remove random formatting changes > -#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0) > -#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear) > +#define uart_set_mctrl(port,set) uart_update_mctrl(port,set,0) > +#define uart_clear_mctrl(port,clear) uart_update_mctrl(port,0,clear) Ditto > > /* > * Startup the port. This will be called once per open. All calls > @@ -291,7 +291,7 @@ uart_update_timeout(struct uart_port *port, unsigned int cflag, > break; > default: > bits = 10; > - break; /* CS8 */ > + break; // CS8 Ditto > - baud = tty_termios_baud_rate(old); > - tty_termios_encode_baud_rate(termios, baud, baud); > + termios->c_cflag |= old->c_cflag & CBAUD; NAK. Breaks the tty layer code > old = NULL; > continue; > } > @@ -382,7 +381,7 @@ uart_get_baud_rate(struct uart_port *port, struct ktermios *termios, > * As a last resort, if the quotient is zero, > * default to 9600 bps > */ > - tty_termios_encode_baud_rate(termios, 9600, 9600); > + termios->c_cflag |= B9600; NAK breaks the tty layer code > +#ifdef CONFIG_PPS_CLIENT_UART wrong layer - this means only some ports will work. > @@ -789,8 +845,7 @@ static int uart_set_info(struct uart_state *state, > * We failed anyway. > */ > retval = -EBUSY; > - /* Added to return the correct error -Ram Gupta */ > - goto exit; > + goto exit; // Added to return the correct error -Ram Gupta More format mangling > + /* PPS support enabled/disabled? */ > + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { How is this flag set ? > -static void uart_set_termios(struct tty_struct *tty, > - struct ktermios *old_termios) > +static void uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios) NAK - more format mangling > { > struct uart_state *state = tty->driver_data; > unsigned long flags; > @@ -1464,8 +1526,9 @@ uart_block_til_ready(struct file *filp, struct uart_state *state) > */ > if ((filp->f_flags & O_NONBLOCK) || > (info->tty->termios->c_cflag & CLOCAL) || > - (info->tty->flags & (1 << TTY_IO_ERROR))) > + (info->tty->flags & (1 << TTY_IO_ERROR))) { And more - and so it goes on. Please clean up the mess and submit a proposal which is just the relevant changes so it can be read. Then we can talk about putting it in the right place. My guess is that PPS like FIR should be a line discipline and they both and a couple of other cases want the tty layer to grow tty->ops->report_event(); and tty->ops->set_event_mask(); for nicer ways to monitor modem bits in the ldisc. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 15:28 ` [PATCH 5/7] PPS: serial " Alan Cox @ 2008-04-10 15:36 ` Rodolfo Giometti 0 siblings, 0 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 15:36 UTC (permalink / raw) To: Alan Cox Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Thu, Apr 10, 2008 at 04:28:12PM +0100, Alan Cox wrote: > On Thu, 10 Apr 2008 17:15:58 +0200 > Rodolfo Giometti <giometti@linux.it> wrote: > > > Adds support for the PPS sources connected with the CD (Carrier > > Detect) pin of a serial port. > > Ok why does this need to hack the driver layer ? > > > -static void uart_change_speed(struct uart_state *state, > > - struct ktermios *old_termios); > > +static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios); > > NAK. Please remove random formatting changes Sorry, this patch is wrong! I'll re-submit the right code. '-_- Thanks, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: LinuxPPS (RESUBMIT 3): the PPS Linux implementation. 2008-04-10 15:15 LinuxPPS (RESUBMIT 3): the PPS Linux implementation Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti @ 2008-04-10 15:28 ` Lennart Sorensen 1 sibling, 0 replies; 35+ messages in thread From: Lennart Sorensen @ 2008-04-10 15:28 UTC (permalink / raw) To: Rodolfo Giometti Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Thu, Apr 10, 2008 at 05:15:53PM +0200, Rodolfo Giometti wrote: > 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. Thank you for keeping at this. Great work. -- Len Sorensen ^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 5/7] PPS: serial clients support. @ 2008-04-10 16:01 Rodolfo Giometti 2008-04-10 16:06 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 16:01 UTC (permalink / raw) To: Alan Cox Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers Adds support for the PPS sources connected with the CD (Carrier Detect) pin of a serial port. Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- drivers/pps/clients/Kconfig | 10 +++++ drivers/serial/8250.c | 2 + drivers/serial/serial_core.c | 81 +++++++++++++++++++++++++++++++++++++++++- include/linux/serial_core.h | 30 ++++++++++++--- 4 files changed, 116 insertions(+), 7 deletions(-) diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig index 60b83be..517c338 100644 --- a/drivers/pps/clients/Kconfig +++ b/drivers/pps/clients/Kconfig @@ -15,4 +15,14 @@ config PPS_CLIENT_KTIMER This driver can also be built as a module. If so, the module will be called ktimer.ko. +comment "UART serial support (forced off)" + depends on ! (SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y)) + +config PPS_CLIENT_UART + bool "UART serial support" + depends on SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y) + 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/serial/8250.c b/drivers/serial/8250.c index 77f7a7f..880cbeb 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2119,6 +2119,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 0f5a179..37e9962 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -635,6 +636,63 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + state->pps_info.owner = THIS_MODULE; + state->pps_info.dev = port->dev; + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); + if (ret < 0) { + dev_err(port->dev, "cannot register PPS source \"%s\"\n", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(port->pps_source); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, state->pps_info.path); +} + +#else + +static inline int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + return 0; +} + +static inline void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + /* Nop */ +} + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -810,11 +868,20 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & + (UPF_SPD_MASK | UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2148,6 +2215,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2405,6 +2478,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 289942f..0f8fbd4 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -166,6 +166,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -245,6 +246,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -289,7 +293,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -322,6 +327,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info pps_info; +#endif + struct mutex mutex; }; @@ -486,13 +495,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; - -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); +#ifdef CONFIG_PPS_CLIENT_UART + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n", + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); -- 1.5.4.3 -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply related [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 16:01 [PATCH 5/7] PPS: serial clients support Rodolfo Giometti @ 2008-04-10 16:06 ` Rodolfo Giometti 2008-04-10 17:41 ` Greg KH 2008-04-10 18:22 ` LinuxPPS (RESUBMIT 4): the PPS Linux implementation Rodolfo Giometti 0 siblings, 2 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 16:06 UTC (permalink / raw) To: Alan Cox Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Thu, Apr 10, 2008 at 06:01:22PM +0200, Rodolfo Giometti wrote: > Adds support for the PPS sources connected with the CD (Carrier > Detect) pin of a serial port. Should I resubmit the whole patch set? Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 16:06 ` Rodolfo Giometti @ 2008-04-10 17:41 ` Greg KH 2008-04-10 18:22 ` LinuxPPS (RESUBMIT 4): the PPS Linux implementation Rodolfo Giometti 1 sibling, 0 replies; 35+ messages in thread From: Greg KH @ 2008-04-10 17:41 UTC (permalink / raw) To: Rodolfo Giometti Cc: Alan Cox, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Randy Dunlap, Kay Sievers On Thu, Apr 10, 2008 at 06:06:30PM +0200, Rodolfo Giometti wrote: > On Thu, Apr 10, 2008 at 06:01:22PM +0200, Rodolfo Giometti wrote: > > Adds support for the PPS sources connected with the CD (Carrier > > Detect) pin of a serial port. > > Should I resubmit the whole patch set? Please do. thanks, greg k-h ^ permalink raw reply [flat|nested] 35+ messages in thread
* LinuxPPS (RESUBMIT 4): the PPS Linux implementation. 2008-04-10 16:06 ` Rodolfo Giometti 2008-04-10 17:41 ` Greg KH @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 1 sibling, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox 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. Rodolfo -- Documentation/pps/Makefile | 2 b/Documentation/ABI/testing/sysfs-pps | 73 +++++++ b/Documentation/ioctl-number.txt | 2 b/Documentation/pps/Makefile | 27 ++ b/Documentation/pps/pps.txt | 170 +++++++++++++++++ b/Documentation/pps/ppsctl.c | 63 ++++++ b/Documentation/pps/ppsfind | 17 + b/Documentation/pps/ppstest.c | 152 +++++++++++++++ b/Documentation/pps/timepps.h | 196 +++++++++++++++++++ b/MAINTAINERS | 7 b/drivers/Kconfig | 2 b/drivers/Makefile | 1 b/drivers/char/lp.c | 61 ++++++ 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 | 115 +++++++++++ b/drivers/pps/kapi.c | 330 +++++++++++++++++++++++++++++++++ b/drivers/pps/pps.c | 335 ++++++++++++++++++++++++++++++++++ b/drivers/pps/sysfs.c | 103 ++++++++++ b/drivers/serial/8250.c | 2 b/drivers/serial/serial_core.c | 81 ++++++++ b/include/linux/Kbuild | 1 b/include/linux/parport.h | 13 + b/include/linux/pps.h | 203 ++++++++++++++++++++ b/include/linux/serial_core.h | 31 ++- drivers/pps/Kconfig | 2 drivers/pps/Makefile | 1 drivers/pps/clients/Kconfig | 20 ++ 30 files changed, 2063 insertions(+), 15 deletions(-) ^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 1/7] LinuxPPS core support. 2008-04-10 18:22 ` LinuxPPS (RESUBMIT 4): the PPS Linux implementation Rodolfo Giometti @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox, Rodolfo Giometti 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 <giometti@linux.it> --- Documentation/ABI/testing/sysfs-pps | 73 ++++++++ Documentation/ioctl-number.txt | 2 + Documentation/pps/pps.txt | 170 ++++++++++++++++++ MAINTAINERS | 7 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/pps/Kconfig | 33 ++++ drivers/pps/Makefile | 8 + drivers/pps/kapi.c | 330 ++++++++++++++++++++++++++++++++++ drivers/pps/pps.c | 335 +++++++++++++++++++++++++++++++++++ drivers/pps/sysfs.c | 103 +++++++++++ include/linux/Kbuild | 1 + include/linux/pps.h | 202 +++++++++++++++++++++ 13 files changed, 1267 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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 c18363b..b4c7d26 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:giometti@linux.it> '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..2b25a48 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,170 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you 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, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for 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 90dcbbc..a67d624 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3171,6 +3171,13 @@ P: James Chapman M: jchapman@katalix.com S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/drivers/Kconfig b/drivers/Kconfig index 3a0e354..0c11e5c 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 e5e394a..adc0924 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -62,6 +62,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..6c72e2e --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,330 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/spinlock.h> +#include <linux/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 + * 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, int event, void *data) +{ + struct pps_device *pps; + struct timespec __ts; + struct pps_ktime ts; + unsigned long flags; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + printk(KERN_ERR "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..a46f8f4 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,335 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/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, + "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 " + "<giometti@linux.it>\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 <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..0520f62 --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,103 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> +#include <linux/pps.h> + +/* + * 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), +}; diff --git a/include/linux/Kbuild b/include/linux/Kbuild index 9cdd12a..0dd702c 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -294,6 +294,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..83a23d2 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,202 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +#define PPS_VERSION "5.1.0" +#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, int event, void *data); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 2/7] PPS: userland header file for PPS API. 2008-04-10 18:22 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox, Rodolfo Giometti 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 <giometti@linux.it> --- 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 <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +#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 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 3/7] PPS: documentation programs and examples. 2008-04-10 18:22 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox, Rodolfo Giometti Here some utilities and examples about the PPS API and the LinuxPPS support. * 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 <giometti@linux.it> --- Documentation/pps/Makefile | 27 ++++++++ Documentation/pps/ppsfind | 17 +++++ Documentation/pps/ppstest.c | 151 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 195 insertions(+), 0 deletions(-) create mode 100644 Documentation/pps/Makefile create mode 100644 Documentation/pps/ppsfind create mode 100644 Documentation/pps/ppstest.c diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..af4f9b4 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section -- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section -- + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/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/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 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 4/7] PPS: LinuxPPS clients support. 2008-04-10 18:22 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox, Rodolfo Giometti 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 <giometti@linux.it> --- drivers/pps/Kconfig | 2 + drivers/pps/Makefile | 1 + drivers/pps/clients/Kconfig | 18 +++++++ drivers/pps/clients/Makefile | 9 +++ drivers/pps/clients/ktimer.c | 114 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 144 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..5845188 --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pr_info("PPS event at %lu\n", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pr_info("echo %s %s for source %d\n", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info 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 <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 5/7] PPS: serial clients support. 2008-04-10 18:22 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti @ 2008-04-10 18:22 ` Rodolfo Giometti 2008-04-10 20:09 ` Alan Cox 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-10 18:22 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Alan Cox, Rodolfo Giometti Adds support for the PPS sources connected with the CD (Carrier Detect) pin of a serial port. Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- drivers/pps/clients/Kconfig | 10 +++++ drivers/serial/8250.c | 2 + drivers/serial/serial_core.c | 81 +++++++++++++++++++++++++++++++++++++++++- include/linux/serial_core.h | 30 ++++++++++++--- 4 files changed, 116 insertions(+), 7 deletions(-) diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig index 60b83be..517c338 100644 --- a/drivers/pps/clients/Kconfig +++ b/drivers/pps/clients/Kconfig @@ -15,4 +15,14 @@ config PPS_CLIENT_KTIMER This driver can also be built as a module. If so, the module will be called ktimer.ko. +comment "UART serial support (forced off)" + depends on ! (SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y)) + +config PPS_CLIENT_UART + bool "UART serial support" + depends on SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y) + 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/serial/8250.c b/drivers/serial/8250.c index 77f7a7f..880cbeb 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2119,6 +2119,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 0f5a179..37e9962 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -635,6 +636,63 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + state->pps_info.owner = THIS_MODULE; + state->pps_info.dev = port->dev; + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); + if (ret < 0) { + dev_err(port->dev, "cannot register PPS source \"%s\"\n", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(port->pps_source); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, state->pps_info.path); +} + +#else + +static inline int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + return 0; +} + +static inline void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + /* Nop */ +} + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -810,11 +868,20 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & + (UPF_SPD_MASK | UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2148,6 +2215,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2405,6 +2478,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 289942f..0f8fbd4 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -166,6 +166,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -245,6 +246,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -289,7 +293,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -322,6 +327,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info pps_info; +#endif + struct mutex mutex; }; @@ -486,13 +495,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; - -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); +#ifdef CONFIG_PPS_CLIENT_UART + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n", + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); -- 1.5.4.3 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 18:22 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti @ 2008-04-10 20:09 ` Alan Cox 2008-04-11 7:55 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-04-10 20:09 UTC (permalink / raw) To: Rodolfo Giometti Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers, Rodolfo Giometti On Thu, 10 Apr 2008 20:22:29 +0200 Rodolfo Giometti <giometti@linux.it> wrote: > Adds support for the PPS sources connected with the CD (Carrier > Detect) pin of a serial port. Better and now readable but this is definitely in the wrong place and should be pushed up the stack so it can be generalised for all serial devices as an ldisc or similar. This bit is definitely not ready to go upstream but the general PPS stuff looks fairly sane. ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-10 20:09 ` Alan Cox @ 2008-04-11 7:55 ` Rodolfo Giometti 2008-04-11 8:28 ` Alan Cox 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-11 7:55 UTC (permalink / raw) To: Alan Cox Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Thu, Apr 10, 2008 at 09:09:18PM +0100, Alan Cox wrote: > On Thu, 10 Apr 2008 20:22:29 +0200 > Rodolfo Giometti <giometti@linux.it> wrote: > > > Adds support for the PPS sources connected with the CD (Carrier > > Detect) pin of a serial port. > > Better and now readable but this is definitely in the wrong place and > should be pushed up the stack so it can be generalised for all serial > devices as an ldisc or similar. How can I do that? From a serial device I just need the IRQ time arrival, no other data at all. How a ldisc can help me in this task? This patch adds PPS support just for UARTs, other devices should provide their own support by using the new provided API. :) Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 7:55 ` Rodolfo Giometti @ 2008-04-11 8:28 ` Alan Cox 2008-04-11 8:49 ` Rodolfo Giometti 2008-04-11 13:47 ` Lennart Sorensen 0 siblings, 2 replies; 35+ messages in thread From: Alan Cox @ 2008-04-11 8:28 UTC (permalink / raw) To: Rodolfo Giometti Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers > How can I do that? From a serial device I just need the IRQ time > arrival, no other data at all. How a ldisc can help me in this task? At the moment you can't. That needs fixing. Most of the infrastructure is there but not all of it. > This patch adds PPS support just for UARTs, other devices should > provide their own support by using the new provided API. :) I do not want PPS code adding to every single serial driver. That way lies madness. We do it once, and in the right layer. I'll take a further look at it after the tty->ops patch is merged. At that point we'll be in a good position to add the needed ops/callbacks. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 8:28 ` Alan Cox @ 2008-04-11 8:49 ` Rodolfo Giometti 2008-04-11 14:43 ` Serge Belyshev 2008-04-11 13:47 ` Lennart Sorensen 1 sibling, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-11 8:49 UTC (permalink / raw) To: Alan Cox Cc: linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, Apr 11, 2008 at 09:28:40AM +0100, Alan Cox wrote: > > How can I do that? From a serial device I just need the IRQ time > > arrival, no other data at all. How a ldisc can help me in this task? > > At the moment you can't. That needs fixing. Most of the infrastructure is > there but not all of it. > > > This patch adds PPS support just for UARTs, other devices should > > provide their own support by using the new provided API. :) > > I do not want PPS code adding to every single serial driver. That way > lies madness. We do it once, and in the right layer. I'll take a further The problem is that deferencing the pps_event() call will cause severe problems to PPS accuracy... here you can find some considerations on this topic: http://ml.enneenne.com/pipermail/linuxpps/2008-April/001738.html > look at it after the tty->ops patch is merged. At that point we'll be in > a good position to add the needed ops/callbacks. Can you please give me an URL where I can see that patch? Thanks a lot for your help, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 8:49 ` Rodolfo Giometti @ 2008-04-11 14:43 ` Serge Belyshev 2008-04-11 16:58 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Serge Belyshev @ 2008-04-11 14:43 UTC (permalink / raw) To: Rodolfo Giometti Cc: Alan Cox, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers Rodolfo Giometti <giometti@enneenne.com> writes: > The problem is that deferencing the pps_event() call will cause severe > problems to PPS accuracy... here you can find some considerations on > this topic: > > http://ml.enneenne.com/pipermail/linuxpps/2008-April/001738.html > What about adding precise timestamping to the lowest possible irq handling level ( arch/*/entry*.S ) and then export that information in a general way so it is useful for other applications? ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 14:43 ` Serge Belyshev @ 2008-04-11 16:58 ` Rodolfo Giometti 0 siblings, 0 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-11 16:58 UTC (permalink / raw) To: Serge Belyshev Cc: Alan Cox, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, Apr 11, 2008 at 06:43:07PM +0400, Serge Belyshev wrote: > Rodolfo Giometti <giometti@enneenne.com> writes: > > > The problem is that deferencing the pps_event() call will cause severe > > problems to PPS accuracy... here you can find some considerations on > > this topic: > > > > http://ml.enneenne.com/pipermail/linuxpps/2008-April/001738.html > > > > What about adding precise timestamping to the lowest possible irq > handling level ( arch/*/entry*.S ) and then export that information > in a general way so it is useful for other applications? The problem is that at such level you cannot easily retrieve info about where your serial port is connected to and which PPS source you should manage... Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 8:28 ` Alan Cox 2008-04-11 8:49 ` Rodolfo Giometti @ 2008-04-11 13:47 ` Lennart Sorensen 2008-04-11 14:46 ` Alan Cox 1 sibling, 1 reply; 35+ messages in thread From: Lennart Sorensen @ 2008-04-11 13:47 UTC (permalink / raw) To: Alan Cox Cc: Rodolfo Giometti, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, Apr 11, 2008 at 09:28:40AM +0100, Alan Cox wrote: > I do not want PPS code adding to every single serial driver. That way > lies madness. We do it once, and in the right layer. I'll take a further > look at it after the tty->ops patch is merged. At that point we'll be in > a good position to add the needed ops/callbacks. I thought it just required that the uart driver call uart_handle_dcd_change when the state of the CD changes, and all the PPS stuff happened in that function. That seems pretty low intrusion, since the serial driver wouldn't need to be touched with the PPS code at all as long as it already calls the uart_handle functions. Now if the driver doesn't generate an IRQ whenever a status line changes, then the driver does need to be updated to do that. Some (like jsm) already do, and have no need for the HARDPPS setting at all. It seems reasonable though that the serial drivers should already have had support for generating interrupts when a status line changes. -- Len Sorensen ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 13:47 ` Lennart Sorensen @ 2008-04-11 14:46 ` Alan Cox 2008-04-30 11:41 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-04-11 14:46 UTC (permalink / raw) To: Lennart Sorensen Cc: Rodolfo Giometti, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers > I thought it just required that the uart driver call > uart_handle_dcd_change when the state of the CD changes, and all the PPS > stuff happened in that function. uart_ is only used by some drivers. We have a whole army of drivers using the tty layer directly and another army of drivers using the USB layer. You also need a sensible way to talk to the devices, identify support and avoid clashing uses of carrier pins. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-11 14:46 ` Alan Cox @ 2008-04-30 11:41 ` Rodolfo Giometti 2008-04-30 16:28 ` Alan Cox 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-04-30 11:41 UTC (permalink / raw) To: Alan Cox Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, Apr 11, 2008 at 03:46:52PM +0100, Alan Cox wrote: > > uart_ is only used by some drivers. We have a whole army of drivers using > the tty layer directly and another army of drivers using the USB layer. > > You also need a sensible way to talk to the devices, identify support and > avoid clashing uses of carrier pins. Hello Alan, if I add a dedicated line discipline to register/unregister the PPS source and I leave the pps_event management into uart_handle_dcd_change() function, it can be acceptable? The uart_handle_dcd_change() is generic and I need the DCD status to correctly manage the pps_event. The USB layer is not useful for PPS stuff. Thanks for your suggestions, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-30 11:41 ` Rodolfo Giometti @ 2008-04-30 16:28 ` Alan Cox 2008-05-02 7:33 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-04-30 16:28 UTC (permalink / raw) To: Rodolfo Giometti Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers > if I add a dedicated line discipline to register/unregister the PPS > source and I leave the pps_event management into > uart_handle_dcd_change() function, it can be acceptable? Keep the two things apart. uart_handle_dcd_change looks a good basis for the UART layer support for drivers serial an LDISC looks right for the top layer We just need the bits in the middle right. I've added the serial layer pass through for the set_ldisc() interface so that bit is done. Probably the main thing we need is to add tty->ldisc.dcd_change() for reporting DCD change back to the line discipline. We could queue it as a TTY_ event but I assume you need it immediately not queued ? > The uart_handle_dcd_change() is generic and I need the DCD status to > correctly manage the pps_event. The USB layer is not useful for PPS > stuff Not every character driver uses drivers/serial or USB. That is fine. What I care about is that you *could* add PPS support to another serial driver cleanly, not that it is done immediately. What matters is the interface, the rest will follow. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-04-30 16:28 ` Alan Cox @ 2008-05-02 7:33 ` Rodolfo Giometti 2008-05-02 10:18 ` Alan Cox 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-05-02 7:33 UTC (permalink / raw) To: Alan Cox Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Wed, Apr 30, 2008 at 05:28:55PM +0100, Alan Cox wrote: > > if I add a dedicated line discipline to register/unregister the PPS > > source and I leave the pps_event management into > > uart_handle_dcd_change() function, it can be acceptable? > > Keep the two things apart. > > uart_handle_dcd_change looks a good basis for the UART layer support for > drivers serial > an LDISC looks right for the top layer > > We just need the bits in the middle right. I've added the serial layer > pass through for the set_ldisc() interface so that bit is done. Probably > the main thing we need is to add tty->ldisc.dcd_change() for reporting > DCD change back to the line discipline. We could queue it as a TTY_ event > but I assume you need it immediately not queued ? Yes, you are right. PPS events should be registered as soon as they arrive, that's why I'd like to put events registration (or at least IRQ timestamps) into do_IRQ() as follow: fastcall unsigned int do_IRQ(struct pt_regs *regs) { struct pt_regs *old_regs; /* high bit used in ret_from_ code */ int irq = ~regs->orig_eax; struct irq_desc *desc = irq_desc + irq; #ifdef CONFIG_4KSTACKS union irq_ctx *curctx, *irqctx; u32 *isp; #endif if (unlikely((unsigned)irq >= NR_IRQS)) { printk(KERN_EMERG "%s: cannot handle IRQ %d\n", __FUNCTION__, irq); BUG(); } pps_irq_event_register(irq); old_regs = set_irq_regs(regs); irq_enter(); but this solution arises two drawbacks: 1) the PPS echo functions should be executed by pps_irq_event_register() into do_IRQ(). Brrrr... :) 2) the shared IRQ line may cause "false" PPS events. The latter drawback can be solved simply not using the shared IRQs for PPS sources but the former is not an easy task... so I suppose we should delay the echo function call at "safer" time, maybe using the function tty->ldisc.dcd_change(). > > The uart_handle_dcd_change() is generic and I need the DCD status to > > correctly manage the pps_event. The USB layer is not useful for PPS > > stuff > > Not every character driver uses drivers/serial or USB. That is fine. What > I care about is that you *could* add PPS support to another serial driver > cleanly, not that it is done immediately. What matters is the interface, > the rest will follow. I see. So what do you suggest to do? Should I add an ldisc to register/unregister serial PPS sources and adding function tty->ldisc.dcd_change() to manage the events? Thanks for your suggestions, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-05-02 7:33 ` Rodolfo Giometti @ 2008-05-02 10:18 ` Alan Cox 2008-05-02 10:45 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-05-02 10:18 UTC (permalink / raw) To: Rodolfo Giometti Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers > I see. So what do you suggest to do? Should I add an ldisc to > register/unregister serial PPS sources and adding function > tty->ldisc.dcd_change() to manage the events? I think so. To me that sounds the ideal solution. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-05-02 10:18 ` Alan Cox @ 2008-05-02 10:45 ` Rodolfo Giometti 2008-05-02 12:56 ` Alan Cox 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-05-02 10:45 UTC (permalink / raw) To: Alan Cox Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, May 02, 2008 at 11:18:37AM +0100, Alan Cox wrote: > > I see. So what do you suggest to do? Should I add an ldisc to > > register/unregister serial PPS sources and adding function > > tty->ldisc.dcd_change() to manage the events? > > I think so. To me that sounds the ideal solution. So I should rewrite the uart_handle_dcd_change() as follow? static inline void uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; struct tty_struct *tty = info->tty; struct tty_ldisc *ld; ld = tty_ldisc_ref(tty); if (ld != NULL) { if (ld->dcd_change) (ld->dcd_change)(tty, port, status); tty_ldisc_deref(ld); } 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->open_wait); else if (tty) tty_hangup(tty); } } Is that right? Thanks a lot, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-05-02 10:45 ` Rodolfo Giometti @ 2008-05-02 12:56 ` Alan Cox 2008-05-02 21:09 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Alan Cox @ 2008-05-02 12:56 UTC (permalink / raw) To: Rodolfo Giometti Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers > So I should rewrite the uart_handle_dcd_change() as follow? > > static inline void > uart_handle_dcd_change(struct uart_port *port, unsigned int status) > { > struct uart_info *info = port->info; > struct tty_struct *tty = info->tty; > struct tty_ldisc *ld; > > ld = tty_ldisc_ref(tty); > if (ld != NULL) { > if (ld->dcd_change) > (ld->dcd_change)(tty, port, status); > tty_ldisc_deref(ld); > } > > port->icount.dcd++; > > #ifdef CONFIG_HARD_PPS > if ((port->flags & UPF_HARDPPS_CD) && status) > hardpps(); > #endif The ifdef bit can go - it will be in your dcd_change callback .. Alan ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-05-02 12:56 ` Alan Cox @ 2008-05-02 21:09 ` Rodolfo Giometti 0 siblings, 0 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-05-02 21:09 UTC (permalink / raw) To: Alan Cox Cc: Lennart Sorensen, linux-kernel, Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Kay Sievers On Fri, May 02, 2008 at 01:56:18PM +0100, Alan Cox wrote: > > So I should rewrite the uart_handle_dcd_change() as follow? > > > > static inline void > > uart_handle_dcd_change(struct uart_port *port, unsigned int status) > > { > > struct uart_info *info = port->info; > > struct tty_struct *tty = info->tty; > > struct tty_ldisc *ld; > > > > ld = tty_ldisc_ref(tty); > > if (ld != NULL) { > > if (ld->dcd_change) > > (ld->dcd_change)(tty, port, status); > > tty_ldisc_deref(ld); > > } > > > > port->icount.dcd++; > > > > #ifdef CONFIG_HARD_PPS > > if ((port->flags & UPF_HARDPPS_CD) && status) > > hardpps(); > > #endif > > The ifdef bit can go - it will be in your dcd_change callback .. The "#ifdef CONFIG_HARD_PPS" is currently into kernel code, is *not* my modification at all. In fact you can find the flag UPF_HARDPPS_CD defined into include/linux/serial_core.h. It's a part of a very old PPS implemention (never merged into mainline) and it was used to enable the PPS layer for serial ports. That's why I didn't define an ldisc but implemented my PPS version using it. :) Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@linux.it Embedded Systems phone: +39 349 2432127 UNIX programming skype: rodolfo.giometti ^ permalink raw reply [flat|nested] 35+ messages in thread
* LinuxPPS (RESUBMIT 2): the PPS Linux implementation. @ 2008-03-06 12:08 Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:08 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap 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. Rodolfo -- Documentation/pps/Makefile | 2 b/Documentation/ABI/testing/sysfs-pps | 73 +++++++ b/Documentation/ioctl-number.txt | 2 b/Documentation/pps/Makefile | 27 ++ b/Documentation/pps/pps.txt | 170 ++++++++++++++++ b/Documentation/pps/ppsctl.c | 63 ++++++ b/Documentation/pps/ppsfind | 17 + b/Documentation/pps/ppstest.c | 152 +++++++++++++++ b/Documentation/pps/timepps.h | 196 +++++++++++++++++++ b/MAINTAINERS | 7 b/drivers/Kconfig | 2 b/drivers/Makefile | 1 b/drivers/char/lp.c | 61 ++++++ 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 | 115 +++++++++++ b/drivers/pps/kapi.c | 272 +++++++++++++++++++++++++++ b/drivers/pps/pps.c | 342 ++++++++++++++++++++++++++++++++++ b/drivers/pps/sysfs.c | 130 ++++++++++++ b/drivers/serial/8250.c | 2 b/drivers/serial/serial_core.c | 71 ++++++- b/include/linux/Kbuild | 1 b/include/linux/parport.h | 13 + b/include/linux/pps.h | 205 ++++++++++++++++++++ b/include/linux/serial_core.h | 31 ++- drivers/pps/Kconfig | 2 drivers/pps/Makefile | 1 drivers/pps/clients/Kconfig | 20 + 30 files changed, 2031 insertions(+), 15 deletions(-) ^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 1/7] LinuxPPS core support. 2008-03-06 12:08 LinuxPPS (RESUBMIT 2): the PPS Linux implementation Rodolfo Giometti @ 2008-03-06 12:09 ` Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:09 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Rodolfo Giometti 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 <giometti@linux.it> --- Documentation/ABI/testing/sysfs-pps | 73 ++++++++ Documentation/ioctl-number.txt | 2 + Documentation/pps/pps.txt | 170 +++++++++++++++++ MAINTAINERS | 7 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/pps/Kconfig | 33 ++++ drivers/pps/Makefile | 8 + drivers/pps/kapi.c | 272 ++++++++++++++++++++++++++++ drivers/pps/pps.c | 342 +++++++++++++++++++++++++++++++++++ drivers/pps/sysfs.c | 130 +++++++++++++ include/linux/Kbuild | 1 + include/linux/pps.h | 204 +++++++++++++++++++++ 13 files changed, 1245 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..881b331 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-pps @@ -0,0 +1,73 @@ +What: /sys/class/pps/ +Date: February 2008 +Contact: Rodolfo Giometti <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 <giometti@linux.it> +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 c18363b..b4c7d26 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:giometti@linux.it> '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..c608aa8 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,170 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you 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, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for 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 fed09b5..40d51c2 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3156,6 +3156,13 @@ P: James Chapman M: jchapman@katalix.com S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/drivers/Kconfig b/drivers/Kconfig index 3a0e354..0c11e5c 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 e5e394a..adc0924 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -62,6 +62,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..c127e66 --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,272 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/spinlock.h> +#include <linux/idr.h> +#include <linux/fs.h> +#include <linux/pps.h> + +/* + * Global variables + */ + +DEFINE_SPINLOCK(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 + */ + +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(&idr_lock); + err = idr_get_new(&pps_idr, pps, &id); + spin_unlock_irq(&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, 0); + init_waitqueue_head(&pps->usage_queue); + + /* 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; + } + + /* Create the sysfs entry */ + err = pps_sysfs_create_source_entry(pps); + if (err < 0) { + printk(KERN_ERR "pps: %s: unable to create sysfs entries\n", + info->name); + goto unregister_cdev; + } + + pr_info("new PPS source %s at ID %d\n", info->name, id); + + return id; + +unregister_cdev: + pps_unregister_cdev(pps); + +free_idr: + spin_lock_irq(&idr_lock); + idr_remove(&pps_idr, id); + spin_unlock_irq(&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); + +void pps_unregister_source(int source) +{ + struct pps_device *pps; + + spin_lock_irq(&idr_lock); + pps = idr_find(&pps_idr, source); + + if (!pps) { + spin_unlock_irq(&idr_lock); + return; + } + + /* This should be done first in order to deny IRQ handlers + * to access PPS structs + */ + + idr_remove(&pps_idr, pps->id); + spin_unlock_irq(&idr_lock); + + wait_event(pps->usage_queue, atomic_read(&pps->usage) == 0); + + pps_sysfs_remove_source_entry(pps); + pps_unregister_cdev(pps); + kfree(pps); +} +EXPORT_SYMBOL(pps_unregister_source); + +void pps_event(int source, int event, void *data) +{ + struct pps_device *pps; + struct timespec __ts; + struct pps_ktime ts; + unsigned long flags; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + printk(KERN_ERR "pps: unknown event (%x) for source %d\n", + event, source); + return; + } + + spin_lock_irqsave(&idr_lock, flags); + pps = idr_find(&pps_idr, source); + + /* If we find a valid PPS source we lock it before leaving + * the lock! + */ + if (pps) + atomic_inc(&pps->usage); + spin_unlock_irqrestore(&idr_lock, flags); + + if (!pps) + return; + + pr_debug("PPS event on source %d at %llu.%06u\n", + pps->id, 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 */ + spin_lock_irqsave(&idr_lock, flags); + atomic_dec(&pps->usage); + wake_up_all(&pps->usage_queue); + spin_unlock_irqrestore(&idr_lock, flags); +} +EXPORT_SYMBOL(pps_event); diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c new file mode 100644 index 0000000..53cce94 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,342 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/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", + 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; + + spin_lock_irq(&idr_lock); + found = idr_find(&pps_idr, pps->id) != NULL; + + /* Lock the PPS source against (possible) deregistration */ + if (found) + atomic_inc(&pps->usage); + + spin_unlock_irq(&idr_lock); + + 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 */ + atomic_dec(&pps->usage); + wake_up_all(&pps->usage_queue); + + 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, + "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; + } + + 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 " + "<giometti@linux.it>\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 <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..c25c91c --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,130 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> +#include <linux/pps.h> + +/* + * 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", + 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", + 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); + +static struct attribute *pps_attrs[] = { + &dev_attr_mode.attr, + &dev_attr_echo.attr, + &dev_attr_name.attr, + &dev_attr_path.attr, + &dev_attr_assert.attr, + &dev_attr_clear.attr, + NULL +}; + +static struct attribute_group pps_group = { + .attrs = pps_attrs, +}; + +/* + * Public functions + */ + +void pps_sysfs_remove_source_entry(struct pps_device *pps) +{ + /* Delete info files */ + sysfs_remove_group(&pps->dev->kobj, &pps_group); +} + +int pps_sysfs_create_source_entry(struct pps_device *pps) +{ + int ret; + + /* Create info files */ + ret = sysfs_create_group(&pps->dev->kobj, &pps_group); + if (ret) + dev_err(pps->dev, "unable to create default sysfs entries"); + + return 0; +} diff --git a/include/linux/Kbuild b/include/linux/Kbuild index aada32f..c4cbd8d 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -297,6 +297,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..c455443 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,204 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +/* Implementation note: the logical states ``assert'' and ``clear'' + * are implemented in terms of the chip register, i.e. ``assert'' + * means the bit is set. */ + +/* + * 3.2 New data structures + */ + +#ifndef __KERNEL__ +#include <linux/types.h> +#include <sys/time.h> +#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> + +#define PPS_VERSION "5.0.0" +#define PPS_MAX_SOURCES 16 /* should be enough... */ + +/* + * 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 */ + wait_queue_head_t usage_queue; + + struct class class_dev; +}; + +/* + * Global variables + */ + +extern spinlock_t idr_lock; +extern struct idr pps_idr; + +/* + * Exported functions + */ + +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, int event, void *data); + +extern int pps_sysfs_create_source_entry(struct pps_device *pps); +extern void pps_sysfs_remove_source_entry(struct pps_device *pps); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ -- 1.5.2.5 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 2/7] PPS: userland header file for PPS API. 2008-03-06 12:09 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti @ 2008-03-06 12:09 ` Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:09 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Rodolfo Giometti 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 <giometti@linux.it> --- 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 <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +#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.2.5 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 3/7] PPS: documentation programs and examples. 2008-03-06 12:09 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti @ 2008-03-06 12:09 ` Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:09 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Rodolfo Giometti Here some utilities and examples about the PPS API and the LinuxPPS support. * 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 <giometti@linux.it> --- Documentation/pps/Makefile | 27 ++++++++ Documentation/pps/ppsfind | 17 +++++ Documentation/pps/ppstest.c | 151 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 195 insertions(+), 0 deletions(-) create mode 100644 Documentation/pps/Makefile create mode 100644 Documentation/pps/ppsfind create mode 100644 Documentation/pps/ppstest.c diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..af4f9b4 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section -- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section -- + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/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/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.2.5 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 4/7] PPS: LinuxPPS clients support. 2008-03-06 12:09 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti @ 2008-03-06 12:09 ` Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:09 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Rodolfo Giometti 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 <giometti@linux.it> --- drivers/pps/Kconfig | 2 + drivers/pps/Makefile | 1 + drivers/pps/clients/Kconfig | 18 +++++++ drivers/pps/clients/Makefile | 9 +++ drivers/pps/clients/ktimer.c | 114 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 144 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..5845188 --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pr_info("PPS event at %lu\n", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pr_info("echo %s %s for source %d\n", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info 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 <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); -- 1.5.2.5 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* [PATCH 5/7] PPS: serial clients support. 2008-03-06 12:09 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti @ 2008-03-06 12:09 ` Rodolfo Giometti 2008-03-20 20:04 ` Andrew Morton 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-06 12:09 UTC (permalink / raw) To: linux-kernel Cc: Andrew Morton, David Woodhouse, Dave Jones, Sam Ravnborg, Greg KH, Randy Dunlap, Rodolfo Giometti Adds support for the PPS sources connected with the CD (Carrier Detect) pin of a serial port. Signed-off-by: Rodolfo Giometti <giometti@linux.it> --- drivers/pps/clients/Kconfig | 10 ++++++ drivers/serial/8250.c | 2 + drivers/serial/serial_core.c | 71 +++++++++++++++++++++++++++++++++++++++++- include/linux/serial_core.h | 30 ++++++++++++++--- 4 files changed, 106 insertions(+), 7 deletions(-) diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig index 60b83be..517c338 100644 --- a/drivers/pps/clients/Kconfig +++ b/drivers/pps/clients/Kconfig @@ -15,4 +15,14 @@ config PPS_CLIENT_KTIMER This driver can also be built as a module. If so, the module will be called ktimer.ko. +comment "UART serial support (forced off)" + depends on ! (SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y)) + +config PPS_CLIENT_UART + bool "UART serial support" + depends on SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y) + 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/serial/8250.c b/drivers/serial/8250.c index 77f7a7f..880cbeb 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2119,6 +2119,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 0f5a179..e35fbef 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -635,6 +636,54 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + state->pps_info.owner = THIS_MODULE; + state->pps_info.dev = port->dev; + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); + if (ret < 0) { + dev_err(port->dev, "cannot register PPS source \"%s\"\n", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(port->pps_source); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, state->pps_info.path); +} + +#else + +#define uart_register_pps_port(state, port) do { } while (0) +#define uart_unregister_pps_port(state, port) do { } while (0) + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -810,11 +859,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2148,6 +2205,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2405,6 +2468,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 289942f..0f8fbd4 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -166,6 +166,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -245,6 +246,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -289,7 +293,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -322,6 +327,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info pps_info; +#endif + struct mutex mutex; }; @@ -486,13 +495,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; - -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); +#ifdef CONFIG_PPS_CLIENT_UART + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n", + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); -- 1.5.2.5 ^ permalink raw reply related [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-03-06 12:09 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti @ 2008-03-20 20:04 ` Andrew Morton 2008-03-21 11:17 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Andrew Morton @ 2008-03-20 20:04 UTC (permalink / raw) To: Rodolfo Giometti Cc: linux-kernel, dwmw2, davej, sam, greg, randy.dunlap, giometti On Thu, 6 Mar 2008 13:09:04 +0100 Rodolfo Giometti <giometti@linux.it> wrote: > Adds support for the PPS sources connected with the CD (Carrier > Detect) pin of a serial port. > > ... > > +#ifdef CONFIG_PPS_CLIENT_UART > + > +static int > +uart_register_pps_port(struct uart_state *state, struct uart_port *port) > +{ > + struct tty_driver *drv = port->info->tty->driver; > + int ret; > + > + state->pps_info.owner = THIS_MODULE; > + state->pps_info.dev = port->dev; > + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", > + drv->driver_name, port->line); > + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", > + drv->name, port->line); umm, why are we hard-wiring "/dev" into the kernel source? Is it just for user-friendly printks? > + state->pps_info.mode = PPS_CAPTUREBOTH | \ > + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ > + PPS_CANWAIT | PPS_TSFMT_TSPEC; > + > + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ > + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); > + if (ret < 0) { > + dev_err(port->dev, "cannot register PPS source \"%s\"\n", > + state->pps_info.path); > + return ret; > + } > + port->pps_source = ret; > + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", > + port->pps_source, state->pps_info.path); > + > + return 0; > +} > + > +static void > +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) > +{ > + pps_unregister_source(port->pps_source); > + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", > + port->pps_source, state->pps_info.path); > +} > + > +#else > + > +#define uart_register_pps_port(state, port) do { } while (0) > +#define uart_unregister_pps_port(state, port) do { } while (0) Please never implement in cpp that which can be implemented in C. These should have been static inlines. That's nicer, matches the CONFIG_PPS_CLIENT_UART=y code and provides type checking. > +#endif /* CONFIG_PPS_CLIENT_UART */ > + > static int uart_set_info(struct uart_state *state, > struct serial_struct __user *newinfo) > { > @@ -810,11 +859,19 @@ static int uart_set_info(struct uart_state *state, > (port->flags & UPF_LOW_LATENCY) ? 1 : 0; > > check_and_exit: > + /* PPS support enabled/disabled? */ > + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { > + if (new_flags & UPF_HARDPPS_CD) > + uart_register_pps_port(state, port); > + else > + uart_unregister_pps_port(state, port); > + } > + > retval = 0; > if (port->type == PORT_UNKNOWN) > goto exit; > if (state->info->flags & UIF_INITIALIZED) { > - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || > + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || > old_custom_divisor != port->custom_divisor) { > /* > * If they're setting up a custom divisor or speed, > @@ -2148,6 +2205,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, > port->ops->config_port(port, flags); > } > > + /* > + * Add the PPS support for the current port. > + */ > + if (port->flags & UPF_HARDPPS_CD) > + uart_register_pps_port(state, port); > + > if (port->type != PORT_UNKNOWN) { > unsigned long flags; > > @@ -2405,6 +2468,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) > mutex_unlock(&state->mutex); > > /* > + * Remove PPS support from the current port. > + */ > + if (port->flags & UPF_HARDPPS_CD) > + uart_unregister_pps_port(state, port); > + > + /* > * Remove the devices from the tty layer > */ > tty_unregister_device(drv->tty_driver, port->line); ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-03-20 20:04 ` Andrew Morton @ 2008-03-21 11:17 ` Rodolfo Giometti 2008-03-21 17:41 ` Andrew Morton 0 siblings, 1 reply; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-21 11:17 UTC (permalink / raw) To: Andrew Morton; +Cc: linux-kernel, dwmw2, davej, sam, greg, randy.dunlap On Thu, Mar 20, 2008 at 01:04:00PM -0700, Andrew Morton wrote: > On Thu, 6 Mar 2008 13:09:04 +0100 > Rodolfo Giometti <giometti@linux.it> wrote: > > > Adds support for the PPS sources connected with the CD (Carrier > > Detect) pin of a serial port. > > > > ... > > > > +#ifdef CONFIG_PPS_CLIENT_UART > > + > > +static int > > +uart_register_pps_port(struct uart_state *state, struct uart_port *port) > > +{ > > + struct tty_driver *drv = port->info->tty->driver; > > + int ret; > > + > > + state->pps_info.owner = THIS_MODULE; > > + state->pps_info.dev = port->dev; > > + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", > > + drv->driver_name, port->line); > > + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", > > + drv->name, port->line); > > umm, why are we hard-wiring "/dev" into the kernel source? Is it just for > user-friendly printks? Yes... :) > > + state->pps_info.mode = PPS_CAPTUREBOTH | \ > > + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ > > + PPS_CANWAIT | PPS_TSFMT_TSPEC; > > + > > + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ > > + PPS_OFFSETASSERT | PPS_OFFSETCLEAR); > > + if (ret < 0) { > > + dev_err(port->dev, "cannot register PPS source \"%s\"\n", > > + state->pps_info.path); > > + return ret; > > + } > > + port->pps_source = ret; > > + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", > > + port->pps_source, state->pps_info.path); > > + > > + return 0; > > +} > > + > > +static void > > +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) > > +{ > > + pps_unregister_source(port->pps_source); > > + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", > > + port->pps_source, state->pps_info.path); > > +} > > + > > +#else > > + > > +#define uart_register_pps_port(state, port) do { } while (0) > > +#define uart_unregister_pps_port(state, port) do { } while (0) > > Please never implement in cpp that which can be implemented in C. These > should have been static inlines. That's nicer, matches the > CONFIG_PPS_CLIENT_UART=y code and provides type checking. Are you saying that I should do: static inline int uart_register_pps_port(struct uart_state *state, struct uart_port *port) { /* Nop */ } static inline void uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) { /* Nop */ } ? Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-03-21 11:17 ` Rodolfo Giometti @ 2008-03-21 17:41 ` Andrew Morton 2008-03-25 10:38 ` Rodolfo Giometti 0 siblings, 1 reply; 35+ messages in thread From: Andrew Morton @ 2008-03-21 17:41 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, dwmw2, davej, sam, greg, randy.dunlap On Fri, 21 Mar 2008 12:17:36 +0100 Rodolfo Giometti <giometti@enneenne.com> wrote: > > > +#else > > > + > > > +#define uart_register_pps_port(state, port) do { } while (0) > > > +#define uart_unregister_pps_port(state, port) do { } while (0) > > > > Please never implement in cpp that which can be implemented in C. These > > should have been static inlines. That's nicer, matches the > > CONFIG_PPS_CLIENT_UART=y code and provides type checking. > > Are you saying that I should do: > > static inline int > uart_register_pps_port(struct uart_state *state, struct uart_port *port) > { > /* Nop */ > } > > static inline void > uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) > { > /* Nop */ > } > > ? Yes please. ^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [PATCH 5/7] PPS: serial clients support. 2008-03-21 17:41 ` Andrew Morton @ 2008-03-25 10:38 ` Rodolfo Giometti 0 siblings, 0 replies; 35+ messages in thread From: Rodolfo Giometti @ 2008-03-25 10:38 UTC (permalink / raw) To: Andrew Morton; +Cc: linux-kernel, dwmw2, davej, sam, greg, randy.dunlap On Fri, Mar 21, 2008 at 10:41:25AM -0700, Andrew Morton wrote: > On Fri, 21 Mar 2008 12:17:36 +0100 Rodolfo Giometti <giometti@enneenne.com> wrote: > > > > > +#else > > > > + > > > > +#define uart_register_pps_port(state, port) do { } while (0) > > > > +#define uart_unregister_pps_port(state, port) do { } while (0) > > > > > > Please never implement in cpp that which can be implemented in C. These > > > should have been static inlines. That's nicer, matches the > > > CONFIG_PPS_CLIENT_UART=y code and provides type checking. > > > > Are you saying that I should do: > > > > static inline int > > uart_register_pps_port(struct uart_state *state, struct uart_port *port) > > { > > /* Nop */ > > } > > > > static inline void > > uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) > > { > > /* Nop */ > > } > > > > ? > > Yes please. Fixed. I'll send a new patch ASAP. Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 35+ messages in thread
end of thread, other threads:[~2008-05-02 21:10 UTC | newest] Thread overview: 35+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2008-04-10 15:15 LinuxPPS (RESUBMIT 3): the PPS Linux implementation Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 2008-04-10 15:15 ` [PATCH 6/7] PPS: example program to enable PPS support on serial ports Rodolfo Giometti 2008-04-10 15:16 ` [PATCH 7/7] PPS: parallel port clients support Rodolfo Giometti 2008-04-10 15:28 ` [PATCH 5/7] PPS: serial " Alan Cox 2008-04-10 15:36 ` Rodolfo Giometti 2008-04-10 15:28 ` LinuxPPS (RESUBMIT 3): the PPS Linux implementation Lennart Sorensen -- strict thread matches above, loose matches on Subject: below -- 2008-04-10 16:01 [PATCH 5/7] PPS: serial clients support Rodolfo Giometti 2008-04-10 16:06 ` Rodolfo Giometti 2008-04-10 17:41 ` Greg KH 2008-04-10 18:22 ` LinuxPPS (RESUBMIT 4): the PPS Linux implementation Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 2008-04-10 18:22 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 2008-04-10 20:09 ` Alan Cox 2008-04-11 7:55 ` Rodolfo Giometti 2008-04-11 8:28 ` Alan Cox 2008-04-11 8:49 ` Rodolfo Giometti 2008-04-11 14:43 ` Serge Belyshev 2008-04-11 16:58 ` Rodolfo Giometti 2008-04-11 13:47 ` Lennart Sorensen 2008-04-11 14:46 ` Alan Cox 2008-04-30 11:41 ` Rodolfo Giometti 2008-04-30 16:28 ` Alan Cox 2008-05-02 7:33 ` Rodolfo Giometti 2008-05-02 10:18 ` Alan Cox 2008-05-02 10:45 ` Rodolfo Giometti 2008-05-02 12:56 ` Alan Cox 2008-05-02 21:09 ` Rodolfo Giometti 2008-03-06 12:08 LinuxPPS (RESUBMIT 2): the PPS Linux implementation Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 1/7] LinuxPPS core support Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 2/7] PPS: userland header file for PPS API Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 3/7] PPS: documentation programs and examples Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 4/7] PPS: LinuxPPS clients support Rodolfo Giometti 2008-03-06 12:09 ` [PATCH 5/7] PPS: serial " Rodolfo Giometti 2008-03-20 20:04 ` Andrew Morton 2008-03-21 11:17 ` Rodolfo Giometti 2008-03-21 17:41 ` Andrew Morton 2008-03-25 10:38 ` Rodolfo Giometti
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox