* [PATCH] LinuxPPS - definitive version @ 2007-07-17 18:05 Rodolfo Giometti 2007-07-23 13:35 ` David Woodhouse 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-17 18:05 UTC (permalink / raw) To: linux-kernel; +Cc: Andrew Morton, David Woodhouse [-- Attachment #1: Type: text/plain, Size: 423 bytes --] Hello, here my last patch for PPS support. In my opinion it should be ok for inclusion... please, let me know if something should be still changed. Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 [-- Attachment #2: ntp-pps-2.6.22.diff --] [-- Type: text/x-diff, Size: 68442 bytes --] diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..a2660a2 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest ppsctl + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section ---------------------------------------------------------- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section ------------------------------------------------------------ + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt new file mode 100644 index 0000000..0617ea4 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,211 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you change the original RFC 2783: + + pps_handle_t type is an opaque __scalar type__ used to represent a + PPS source within the API + +into a modified: + + pps_handle_t type is an opaque __variable__ used to represent a PPS + source within the API and programs should not access it directly to + it due to its opacity. + +This change seems to be neglibile because even the original RFC 2783 +does not encourage programs to check (read: use) the pps_handle_t +variable before calling the time_pps_*() functions, since each +function should do this job internally. + +If I intentionally separate the concept of "file descriptor" from the +concept of the "PPS source" I'm obliged to provide a solution to find +and register a PPS-source without using a file descriptor: it's done +by the functions time_pps_findsource() and time_pps_findpath() now. + +According to this current NTPD drivers' code should be modified as +follows: + ++#ifdef PPS_HAVE_FINDPATH ++ /* Get the PPS source's real name */ ++ fd = readlink(link, path, STRING_LEN-1); ++ if (fd <= 0) ++ strncpy(path, link, STRING_LEN); ++ else ++ path[fd] = '\0'; ++ ++ /* Try to find the source */ ++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); ++ if (fd < 0) { ++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" " ++ "in the system", path); ++ return 1; ++ } ++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"", ++ fd, path, id); ++#endif /* PPS_HAVE_FINDPATH */ ++ ++ + if (time_pps_create(fd, &pps_handle) < 0) { +- pps_handle = 0; + msyslog(LOG_ERR, "refclock: time_pps_create failed: %m"); + } + + +Coding example +-------------- + +To register a PPS source into the kernel you should define a struct +pps_source_info_s as follow: + + static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, + }; + +and then calling the function pps_register_source() in your +intialization routine as follow: + + source = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + +The pps_register_source() prototype is: + + int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) + +where "info" is a pointer to a structure that describes a particular +PPS source, "default_params" tells the system what the initial default +parameters for the device should be (is obvious that these parameters +must be a subset of ones defined into the struct +pps_source_info_s which describe the capabilities of the driver) +and "try_id" can be used to force a particular ID for your device into +the system (just use -1 if you wish the system chooses one for you). + +Once you have registered a new PPS source into the system you can +signal an assert event (for example in the interrupt handler routine) +just using: + + pps_event(source, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for an example code. + + +SYSFS support +------------- + +The SYSFS support is enabled by default if the SYSFS filesystem is +enabled in the kernel and it provides a new class: + + $ ls /sys/class/pps/ + 00/ 01/ 02/ + +Every directory is the ID of a PPS sources defined into the system and +inside you find several files: + + $ ls /sys/class/pps/00/ + assert clear echo mode name path subsystem@ uevent + +Inside each "assert" and "clear" file you can find the timestamp and a +sequence number: + + $ cat /sys/class/pps/00/assert + 1170026870.983207967#8 + +Where before the "#" is the timestamp in seconds and after it is the +sequence number. Other files are: + +* echo: reports if the PPS source has an echo function or not; + +* mode: reports available PPS functioning modes; + +* name: reports the PPS source's name; + +* path: reports the PPS source's device path, that is the device the + PPS source is connected to (if it exists). + + +Testing the PPS support +----------------------- + +In order to test the PPS support even without specific hardware you can use +the ktimer driver (see the client subsection in the PPS configuration menu) +and the userland tools provided into Documentaion/pps/ directory. + +Once you have enabled the compilation of ktimer just modprobe it (if +not statically compiled): + + # modprobe ktimer + +and the run ppstest as follow: + + $ ./ppstest + found PPS source #0 "ktimer" on "" + ok, found 1 source(s), now start fetching data... + source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0 + source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0 + +Please, note that to compile userland programs you need the file timepps.h +(see Documentaion/pps/). \ No newline at end of file diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c new file mode 100644 index 0000000..e6ab2b9 --- /dev/null +++ b/Documentation/pps/ppsctl.c @@ -0,0 +1,61 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <string.h> +#include <linux/serial.h> + +void usage(char *name) +{ + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name); + + exit(EXIT_FAILURE); +} + +int main(int argc, char *argv[]) +{ + int fd, ret; + struct serial_struct ss; + + if (argc < 2) + usage(argv[0]); + + fd = open(argv[1], O_RDWR); + if (fd < 0) { + perror("open"); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCGSERIAL, &ss); + if (ret < 0 ) { + perror("ioctl(TIOCGSERIAL)"); + exit(EXIT_FAILURE); + } + + if (argc < 3) { /* just read PPS status */ + printf("PPS is %sabled\n", + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis"); + exit(EXIT_SUCCESS); + } + + if (argv[2][0] == 'e' || argv[2][0] == '1') + ss.flags |= ASYNC_HARDPPS_CD; + else if (argv[2][0] == 'd' || argv[2][0] == '0') + ss.flags &= ~ASYNC_HARDPPS_CD; + else { + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCSSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCSSERIAL)"); + exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c new file mode 100644 index 0000000..efbe28f --- /dev/null +++ b/Documentation/pps/ppstest.c @@ -0,0 +1,199 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <timepps.h> + +#define STRING_LEN PPS_MAX_NAME_LEN + +int find_source(int try_link, char *link, pps_handle_t *handle, int *avail_mode) +{ + int num = -1; + char id[STRING_LEN] = "", /* no ID string by default */ + path[STRING_LEN]; + pps_params_t params; + int ret; + + if (try_link) { + printf("trying PPS source \"%s\"\n", link); +#ifdef PPS_HAVE_FINDPATH + /* Get the PPS source's real name */ + time_pps_readlink(link, STRING_LEN, path, STRING_LEN); + + /* Try to find the source by using the supplied "path" name */ + ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); + if (ret < 0) + goto exit; + num = ret; +#else +#warning "cannot use time_pps_findpath()" + ret = -1; +#endif /* PPS_HAVE_FINDPATH */ + } + +#ifdef PPS_HAVE_FINDSOURCE + /* Try to find the source (by using "index = -1" we ask just + * for a generic source) */ + ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN); +#else +#warning "cannot use time_pps_findsource()" + ret = -1; +#endif /* PPS_HAVE_FINDSOURCE */ + if (ret < 0) { +exit: + fprintf(stderr, "no available PPS source in the system\n"); + return -1; + } + num = ret; + printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path); + + /* If "path" is not NULL we should *at least* open the pointed + * device in order to enable the interrupts generation. + * Note that this can be NOT enough anyway, infact you may need sending + * additional commands to your GPS antenna before it starts sending + * the PPS signal. */ + if (strlen(path)) { + ret = open(path, O_RDWR); + if (ret < 0) { + fprintf(stderr, "cannot open \"%s\" (%m)\n", path); + return -1; + } + } + + /* Open the PPS source */ + ret = time_pps_create(num, handle); + if (ret < 0) { + fprintf(stderr, "cannot create a PPS source (%m)\n"); + return -1; + } + + /* Find out what features are supported */ + ret = time_pps_getcap(*handle, avail_mode); + if (ret < 0) { + fprintf(stderr, "cannot get capabilities (%m)\n"); + return -1; + } + if ((*avail_mode & PPS_CAPTUREASSERT) == 0) { + fprintf(stderr, "cannot CAPTUREASSERT\n"); + return -1; + } + if ((*avail_mode & PPS_OFFSETASSERT) == 0) { + fprintf(stderr, "cannot OFFSETASSERT\n"); + return -1; + } + + /* Capture assert timestamps, and compensate for a 675 nsec + * propagation delay */ + ret = time_pps_getparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot get parameters (%m)\n"); + return -1; + } + params.assert_offset.tv_sec = 0; + params.assert_offset.tv_nsec = 675; + params.mode |= PPS_CAPTUREASSERT|PPS_OFFSETASSERT; + ret = time_pps_setparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot set parameters (%m)\n"); + return -1; + } + + return 0; +} + +int fetch_source(int i, pps_handle_t *handle, int *avail_mode) +{ + struct timespec timeout; + pps_info_t infobuf; + int ret; + + /* create a zero-valued timeout */ + timeout.tv_sec = 3; + timeout.tv_nsec = 0; + +retry : + if (*avail_mode&PPS_CANWAIT) { + /* waits for the next event */ + ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout); + } + else { + sleep(1); + ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, &timeout); + } + if (ret < 0) { + if (ret == -EINTR) { + fprintf(stderr, "time_pps_fetch() got a signal!\n"); + goto retry; + } + + fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret); + return -1; + } + + printf("source %d - " + "assert %ld.%09ld, sequence: %ld - " + "clear %ld.%09ld, sequence: %ld\n", + i, + infobuf.assert_timestamp.tv_sec, + infobuf.assert_timestamp.tv_nsec, + infobuf.assert_sequence, + infobuf.clear_timestamp.tv_sec, + infobuf.clear_timestamp.tv_nsec, + infobuf.clear_sequence); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int num, + try_link = 0; /* by default use findsource */ + char link[STRING_LEN] = "/dev/gps0"; /* just a default device */ + pps_handle_t handle[4]; + int avail_mode[4]; + int i = 0, ret; + + if (argc == 1) { + ret = find_source(try_link, link, &handle[0], &avail_mode[0]); + if (ret < 0) + exit(EXIT_FAILURE); + + num = 1; + } + else { + for (i = 1; i < argc && i <= 4; i++) { + ret = sscanf(argv[i], "%d", &num); + if (ret < 1) { + try_link = ~0; + strncpy(link, argv[i], STRING_LEN); + } + + ret = find_source(try_link, link, &handle[i-1], &avail_mode[i-1]); + if (ret < 0) + exit(EXIT_FAILURE); + } + + num = i-1; + } + + printf("ok, found %d source(s), now start fetching data...\n", num); + + /* loop, printing the most recent timestamp every second or so */ + while (1) { + for (i = 0; i < num; i++) { + ret = fetch_source(i, &handle[i], &avail_mode[i]); + if (ret < 0 && errno != ETIMEDOUT) + exit(EXIT_FAILURE); + } + } + + for (; i >= 0; i--) + time_pps_destroy(handle[i]); + + return 0; +} diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h new file mode 100644 index 0000000..86850a1 --- /dev/null +++ b/Documentation/pps/timepps.h @@ -0,0 +1,236 @@ +/* + * timepps.h -- PPS API main header + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +/* + * New data structures + */ + +struct ntp_fp { + unsigned int integral; + unsigned int fractional; +}; + +union pps_timeu { + struct timespec tspec; + struct ntp_fp ntpfp; + unsigned long longpad[3]; +}; + +struct pps_info { + unsigned long assert_sequence; /* seq. num. of assert event */ + unsigned long clear_sequence; /* seq. num. of clear event */ + union pps_timeu assert_tu; /* time of assert event */ + union pps_timeu clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_params { + int api_version; /* API version # */ + int mode; /* mode bits */ + union pps_timeu assert_off_tu; /* offset compensation for assert */ + union pps_timeu clear_off_tu; /* offset compensation for clear */ +}; + +typedef int pps_handle_t; /* represents a PPS source */ +typedef unsigned long pps_seq_t; /* sequence number */ +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */ +typedef struct pps_info pps_info_t; +typedef struct pps_params pps_params_t; + +#define assert_timestamp assert_tu.tspec +#define clear_timestamp clear_tu.tspec + +#define assert_timestamp_ntpfp assert_tu.ntpfp +#define clear_timestamp_ntpfp clear_tu.ntpfp + +#define assert_offset assert_off_tu.tspec +#define clear_offset clear_off_tu.tspec + +#define assert_offset_ntpfp assert_off_tu.ntpfp +#define clear_offset_ntpfp clear_off_tu.ntpfp + +/* + * The PPS API + */ + +#define PPS_HAVE_FINDSOURCE 1 +#define pps_min(a, b) (a) < (b) ? a : b +int time_pps_findsource(int index, char *path, int pathlen, char *idstring, int idlen) +{ + struct pps_source_data_s data; + int ret; + + data.source = index; + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +/* Defined iff PPS_HAVE_FINDPATH is defined */ +void time_pps_readlink(char *link, int linklen, char *path, int pathlen) +{ + int i; + + i = readlink(link, path, pathlen - 1); + if (i <= 0) { + /* "link" is not a valid symbolic so we directly use it */ + strncpy(path, link, linklen <= pathlen ? linklen : pathlen); + return; + } + + /* Return the file name where "link" points to */ + path[i] = '\0'; +} + +#define PPS_HAVE_FINDPATH 1 +int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen) +{ + struct pps_source_data_s data; + int ret; + + strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +int time_pps_create(int source, pps_handle_t *handle) +{ + if (!handle) { + errno = EINVAL; + return -1; + } + + /* In LinuxPPS there are no differences between a PPS source and + * a PPS handle so we return the same value. + */ + *handle = source; + + return 0; +} + +int time_pps_destroy(pps_handle_t handle) +{ + /* Nothing to destroy here */ + + return 0; +} + +int time_pps_getparams(pps_handle_t handle, + pps_params_t *ppsparams) +{ + int ret; + struct pps_kparams __ppsparams; + + ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams); + + ppsparams->api_version = __ppsparams.api_version; + ppsparams->mode = __ppsparams.mode; + ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec; + ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec; + ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec; + ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec; + + return ret; +} + +int time_pps_setparams(pps_handle_t handle, + const pps_params_t *ppsparams) +{ + struct pps_kparams __ppsparams; + + __ppsparams.api_version = ppsparams->api_version; + __ppsparams.mode = ppsparams->mode; + __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec; + __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec; + __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec; + __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec; + + return syscall(__NR_time_pps_getparams, handle, &__ppsparams); +} + +/* Get capabilities for handle */ +int time_pps_getcap(pps_handle_t handle, int *mode) +{ + return syscall(__NR_time_pps_getcap, handle, mode); +} + +int time_pps_fetch(pps_handle_t handle, const int tsformat, + pps_info_t *ppsinfobuf, + const struct timespec *timeout) +{ + struct pps_kinfo __ppsinfobuf; + struct pps_ktime __timeout; + int ret; + + /* Sanity checks */ + if (tsformat != PPS_TSFMT_TSPEC) { + errno = EINVAL; + return -1; + } + + if (timeout) { + __timeout.sec = timeout->tv_sec; + __timeout.nsec = timeout->tv_nsec; + } + + ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf, + timeout ? &__timeout : NULL); + + ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence; + ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence; + ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec; + ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec; + ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec; + ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec; + ppsinfobuf->current_mode = __ppsinfobuf.current_mode; + + return ret; +} + +int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer, + const int edge, const int tsformat) +{ + /* LinuxPPS doesn't implement kernel consumer feature */ + errno = EOPNOTSUPP; + return -1; +} + +#endif /* _SYS_TIMEPPS_H_ */ diff --git a/MAINTAINERS b/MAINTAINERS index df40a4e..17e9a02 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2903,6 +2903,13 @@ P: Michal Ostrowski M: mostrows@speakeasy.net S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S index bf6adce..f1bf4ff 100644 --- a/arch/i386/kernel/syscall_table.S +++ b/arch/i386/kernel/syscall_table.S @@ -323,3 +323,8 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_time_pps_cmd + .long sys_time_pps_getparams /* 325 */ + .long sys_time_pps_setparams + .long sys_time_pps_getcap + .long sys_time_pps_fetch diff --git a/drivers/Kconfig b/drivers/Kconfig index 050323f..bb54cab 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig" source "drivers/spi/Kconfig" +source "drivers/pps/Kconfig" + source "drivers/w1/Kconfig" source "drivers/hwmon/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index adad2f3..985d495 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_I2O) += message/ obj-$(CONFIG_RTC_LIB) += rtc/ obj-y += i2c/ +obj-$(CONFIG_PPS) += pps/ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/ obj-$(CONFIG_PHONE) += telephony/ diff --git a/drivers/char/lp.c b/drivers/char/lp.c index 62051f8..a50b336 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -746,6 +746,27 @@ static struct console lpcons = { #endif /* console on line printer */ +/* Support for PPS signal on the line printer */ + +#ifdef CONFIG_PPS_CLIENT_LP + +static void lp_pps_echo(int source, int event, void *data) +{ + struct parport *port = data; + unsigned char status = parport_read_status(port); + + /* echo event via SEL bit */ + parport_write_control(port, + parport_read_control(port) | PARPORT_CONTROL_SELECT); + + /* signal no event */ + if ((status & PARPORT_STATUS_ACK) != 0) + parport_write_control(port, + parport_read_control(port) & ~PARPORT_CONTROL_SELECT); +} + +#endif + /* --- initialisation code ------------------------------------- */ static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC }; @@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port) } #endif +#ifdef CONFIG_PPS_CLIENT_LP + snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr); + + /* No PPS support if lp port has no IRQ line */ + if (port->irq != PARPORT_IRQ_NONE) { + strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN); + + port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + port->pps_info.echo = lp_pps_echo; + + port->pps_source = pps_register_source(&(port->pps_info), + PPS_CAPTUREASSERT | PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (port->pps_source < 0) + pps_err("cannot register PPS source \"%s\"", + port->pps_info.path); + else + pps_info("PPS source #%d \"%s\" added to the system", + port->pps_source, port->pps_info.path); + } else { + port->pps_source = -1; + pps_err("PPS support disabled due port \"%s\" is in polling mode", + port->pps_info.path); + } +#endif + return 0; } @@ -860,6 +910,14 @@ static void lp_detach (struct parport *port) console_registered = NULL; } #endif /* CONFIG_LP_CONSOLE */ + +#ifdef CONFIG_PPS_CLIENT_LP + if (port->pps_source >= 0) { + pps_unregister_source(&(port->pps_info)); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, port->pps_info.path); + } +#endif } static struct parport_driver lp_driver = { diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig new file mode 100644 index 0000000..1d16f14 --- /dev/null +++ b/drivers/pps/Kconfig @@ -0,0 +1,34 @@ +# +# Character device configuration +# + +menu "PPS support" + +config PPS + bool "PPS support" + depends on EXPERIMENTAL + ---help--- + PPS (Pulse Per Second) is a special pulse provided by some GPS + antennae. Userland can use it to get an high time reference. + + Some antennae's PPS signals are connected with the CD (Carrier + Detect) pin of the serial line they use to communicate with the + host. In this case use the SERIAL_LINE client support. + + Some antennae's PPS signals are connected with some special host + inputs so you have to enable the corresponding client support. + + This PPS support can also be built as a module. If so, the module + will be called pps-core. + +config PPS_DEBUG + bool "PPS debugging messages" + depends on PPS + help + Say Y here if you want the PPS support to produce a bunch of debug + messages to the system log. Select this if you are having a + problem with PPS support and want to see more of what is going on. + +source drivers/pps/clients/Kconfig + +endmenu diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile new file mode 100644 index 0000000..76101cd --- /dev/null +++ b/drivers/pps/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the PPS core. +# + +pps_core-objs += pps.o kapi.o sysfs.o +obj-$(CONFIG_PPS) += pps_core.o +obj-y += clients/ diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig new file mode 100644 index 0000000..867df3a --- /dev/null +++ b/drivers/pps/clients/Kconfig @@ -0,0 +1,30 @@ +# +# LinuxPPS clients configuration +# + +if PPS + +comment "PPS clients support" + +config PPS_CLIENT_KTIMER + tristate "Kernel timer client (Testing client, use for debug)" + help + If you say yes here you get support for a PPS debugging client + which uses a kernel timer to generate the PPS signal. + + This driver can also be built as a module. If so, the module + will be called ktimer.o. + +config PPS_CLIENT_UART + bool "UART serial support" + help + If you say yes here you get support for a PPS source connected + with the CD (Carrier Detect) pin of your serial port. + +config PPS_CLIENT_LP + bool "Parallel printer support" + help + If you say yes here you get support for a PPS source connected + with the interrupt pin of your parallel port. + +endif diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile new file mode 100644 index 0000000..3ecca41 --- /dev/null +++ b/drivers/pps/clients/Makefile @@ -0,0 +1,6 @@ +# +# Makefile for miscellaneous I2C chip drivers. +# + +obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o + diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c new file mode 100644 index 0000000..e9e5c47 --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,113 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pps_info("PPS event at %lu", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pps_info("echo %s %s for source %d", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT|PPS_OFFSETASSERT|PPS_ECHOASSERT| \ + PPS_CANWAIT|PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, +}; + +/* + * Module staff + */ + +static void __exit pps_ktimer_exit(void) +{ + del_timer_sync(&ktimer); + pps_unregister_source(&pps_ktimer_info); + + pps_info("ktimer PPS source unregistered"); +} + +static int __init pps_ktimer_init(void) +{ + int ret; + + ret = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (ret < 0) { + pps_err("cannot register ktimer source"); + return ret; + } + source = ret; + + setup_timer(&ktimer, pps_ktimer_event, 0); + mod_timer(&ktimer, jiffies + HZ); + + pps_info("ktimer PPS source registered at %d", source); + + return 0; +} + +module_init(pps_ktimer_init); +module_exit(pps_ktimer_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("testing PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c new file mode 100644 index 0000000..977aa14 --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,215 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/pps.h> + +/* + * Local functions + */ + +static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset) +{ + ts->nsec += offset->nsec; + if (ts->nsec >= NSEC_PER_SEC) { + ts->nsec -= NSEC_PER_SEC; + ts->sec++; + } else if (ts->nsec < 0) { + ts->nsec += NSEC_PER_SEC; + ts->sec--; + } + ts->sec += offset->sec; +} + +/* + * Exported functions + */ + +int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) +{ + int i = -1, err = 0, ret; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + if (try_id >= 0) { + if (pps_is_allocated(try_id)) { + pps_err("source id %d busy", try_id); + err = -EBUSY; + goto pps_register_source_exit; + } + i = try_id; + } else { + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (!pps_is_allocated(i)) + break; + if (i >= PPS_MAX_SOURCES) { + pps_err("no free source ids"); + err = -ENOMEM; + goto pps_register_source_exit; + } + } + + /* Sanity checks */ + if ((info->mode & default_params) != default_params) { + pps_err("unsupported default parameters"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 && + info->echo == NULL) { + pps_err("echo function is not defined"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + pps_err("unspecified time format"); + err = -EINVAL; + goto pps_register_source_exit; + } + + /* Allocate the PPS source. + * + * Note that we should reset all fields BUT "info" one! */ + memset(&(pps_source[i].params), 0, sizeof(struct pps_kparams)); + pps_source[i].params.api_version = PPS_API_VERS; + pps_source[i].params.mode = default_params; + pps_source[i].assert_sequence = 0; + pps_source[i].clear_sequence = 0; + pps_source[i].current_mode = 0; + pps_source[i].go = 0; + init_waitqueue_head(&pps_source[i].queue); + + /* Allocate the PPS source */ + pps_source[i].info = info; + +pps_register_source_exit : + mutex_unlock(&pps_mutex); + + if (err < 0) + return err; + + ret = pps_sysfs_create_source_entry(info, i); + if (ret < 0) + pps_err("unable to create sysfs entry for source %d", i); + + return i; +} +EXPORT_SYMBOL(pps_register_source); + +void pps_unregister_source(struct pps_source_info_s *info) +{ + int i; + + pps_sysfs_remove_source_entry(info); + + if (mutex_lock_interruptible(&pps_mutex)) + return; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && pps_source[i].info == info) + break; + + if (i >= PPS_MAX_SOURCES) { + pps_err("warning! Try to unregister an unknow PPS source"); + goto pps_unregister_source_exit; + } + + /* Deallocate the PPS source */ + pps_source[i].info = &dummy_info; + +pps_unregister_source_exit : + mutex_unlock(&pps_mutex); +} +EXPORT_SYMBOL(pps_unregister_source); + +void pps_event(int source, int event, void *data) +{ + struct timespec __ts; + struct pps_ktime ts; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { + pps_err("unknow event (%x) for source %d", event, source); + return; + } + + /* We wish not using locks at all into this function... a possible + * solution is to check the "info" field against the pointer to + * "dummy_info". + * If "info" points to "dummy_info" we can return doing nothing since, + * even if a new PPS source is registered by another CPU we can + * safely not register current event. + * If "info" points to a valid PPS source's info data we can continue + * without problem since, even if current PPS source is deregistered + * by another CPU, we still continue writing data into a valid area + * (dummy_info). + */ + if (pps_source[source].info == &dummy_info) + return; + + /* Must call the echo function? */ + if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) + pps_source[source].info->echo(source, event, data); + + /* Check the event */ + pps_source[source].current_mode = pps_source[source].params.mode; + if (event & PPS_CAPTUREASSERT) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETASSERT) + pps_add_offset(&ts, + &pps_source[source].params.assert_off_tu); + + /* Save the time stamp */ + pps_source[source].assert_tu = ts; + pps_source[source].assert_sequence++; + pps_dbg("capture assert seq #%u for source %d", + pps_source[source].assert_sequence, source); + } + if (event & PPS_CAPTURECLEAR) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETCLEAR) + pps_add_offset(&ts, + &pps_source[source].params.clear_off_tu); + + /* Save the time stamp */ + pps_source[source].clear_tu = ts; + pps_source[source].clear_sequence++; + pps_dbg("capture clear seq #%u for source %d", + pps_source[source].clear_sequence, source); + } + + pps_source[source].go = ~0; + wake_up_interruptible(&pps_source[source].queue); +} +EXPORT_SYMBOL(pps_event); diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c new file mode 100644 index 0000000..42b5e11 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,398 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/version.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/linkage.h> +#include <linux/sched.h> +#include <linux/pps.h> +#include <asm/uaccess.h> + +/* + * Global variables + */ + +struct pps_s pps_source[PPS_MAX_SOURCES]; +DEFINE_MUTEX(pps_mutex); + +void dummy_echo(int source, int event, void *data) { } +struct pps_source_info_s dummy_info; /* Dummy PPS info for unallocated + PPS sources */ + +/* + * Misc functions + */ + +static inline int pps_check_source(int source) +{ + return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0; +} + +static int pps_find_source(int source) +{ + int i; + + if (source >= 0) { + if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source)) + return -EINVAL; + else + return source; + } + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +static int pps_find_path(char *path) +{ + int i; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && + (strncmp(pps_source[i].info->path, path, + PPS_MAX_NAME_LEN) == 0 || + strncmp(pps_source[i].info->name, path, + PPS_MAX_NAME_LEN) == 0)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +/* + * PPS System Calls + */ + +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg) +{ + struct pps_source_data_s data; + int ret = 0; + + pps_dbg("%s: cmd %d", __FUNCTION__, cmd); + + /* Sanity checks */ + if (_IOC_TYPE(cmd) != 'P') + return -EOPNOTSUPP; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + switch (cmd) { + case PPS_CMD_FIND_SRC : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source); + + data.source = pps_find_source(data.source); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + case PPS_CMD_FIND_PATH : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path); + + data.source = pps_find_path(data.path); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + default : + pps_err("invalid sys_time_pps_cmd %d", cmd); + ret = -EOPNOTSUPP; + goto sys_time_pps_cmd_exit; + } + + /* Found! So copy the info */ + strncpy(data.name, pps_source[data.source].info->name, + PPS_MAX_NAME_LEN); + strncpy(data.path, pps_source[data.source].info->path, + PPS_MAX_NAME_LEN); + + ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s)); + if (ret) + ret = -EFAULT; + +sys_time_pps_cmd_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params) +{ + int ret = 0; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!params) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getparams_exit; + } + + /* Return current parameters */ + ret = copy_to_user(params, &pps_source[source].params, + sizeof(struct pps_kparams)); + if (ret) + ret = -EFAULT; + +sys_time_pps_getparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Check the capabilities */ + if (!capable(CAP_SYS_TIME)) + return -EPERM; + + /* Sanity checks */ + if (!params) + return -EINVAL; + if ((params->mode & ~pps_source[source].info->mode) != 0) { + pps_dbg("unsupported capabilities"); + return -EINVAL; + } + if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + pps_dbg("capture mode unspecified"); + return -EINVAL; + } + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_setparams_exit; + } + + /* Save the new parameters */ + ret = copy_from_user(&pps_source[source].params, params, + sizeof(struct pps_kparams)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_setparams_exit; + } + + /* Restore the read only parameters */ + if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + /* section 3.3 of RFC 2783 interpreted */ + pps_dbg("time format unspecified"); + pps_source[source].params.mode |= PPS_TSFMT_TSPEC; + } + if (pps_source[source].info->mode & PPS_CANWAIT) + pps_source[source].params.mode |= PPS_CANWAIT; + pps_source[source].params.api_version = PPS_API_VERS; + +sys_time_pps_setparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getcap(int source, int __user *mode) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!mode) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getcap_exit; + } + + ret = put_user(pps_source[source].info->mode, mode); + +sys_time_pps_getcap_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout) +{ + unsigned long ticks; + struct pps_kinfo pi; + struct pps_ktime to; + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + if (!info) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_fetch_exit; + } + + pps_source[source].go = 0; + + /* Manage the timeout */ + if (timeout) { + ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime)); + if (ret) { + goto sys_time_pps_fetch_exit; + ret = -EFAULT; + } + pps_dbg("timeout %lld.%09d", to.sec, to.nsec); + ticks = to.sec * HZ; + ticks += to.nsec / (NSEC_PER_SEC / HZ); + + if (ticks != 0) { + ret = wait_event_interruptible_timeout( + pps_source[source].queue, + pps_source[source].go, ticks); + if (ret == 0) { + pps_dbg("timeout expired"); + ret = -ETIMEDOUT; + goto sys_time_pps_fetch_exit; + } + } + } else + ret = wait_event_interruptible(pps_source[source].queue, + pps_source[source].go); + + /* Check for pending signals */ + if (ret == -ERESTARTSYS) { + pps_dbg("pending signal caught"); + ret = -EINTR; + goto sys_time_pps_fetch_exit; + } + + /* Return the fetched timestamp */ + pi.assert_sequence = pps_source[source].assert_sequence; + pi.clear_sequence = pps_source[source].clear_sequence; + pi.assert_tu = pps_source[source].assert_tu; + pi.clear_tu = pps_source[source].clear_tu; + pi.current_mode = pps_source[source].current_mode; + ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo)); + if (ret) + ret = -EFAULT; + +sys_time_pps_fetch_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +/* + * Module staff + */ + +static void __exit pps_exit(void) +{ + pps_sysfs_unregister(); + + pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS); +} + +static int __init pps_init(void) +{ + int i, ret; + + /* Init pps_source info */ + dummy_info.echo = dummy_echo; + for (i = 0; i < PPS_MAX_SOURCES; i++) { + pps_source[i].info = &dummy_info; + init_waitqueue_head(&pps_source[i].queue); + } + + /* Register to sysfs */ + ret = pps_sysfs_register(); + if (ret < 0) { + pps_err("unable to register sysfs"); + return ret; + } + + pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS); + pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti " + "<giometti@linux.it>", PPS_VERSION); + + return 0; +} + +subsys_initcall(pps_init); +module_exit(pps_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..e52dd8e --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,217 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> + +#include <linux/pps.h> + +/* + * Private functions + */ + +static ssize_t pps_show_assert(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->assert_tu.sec, dev->assert_tu.nsec, + dev->assert_sequence); +} + +static ssize_t pps_show_clear(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->clear_tu.sec, dev->clear_tu.nsec, + dev->clear_sequence); +} + +static ssize_t pps_show_mode(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%4x\n", info->mode); +} + +static ssize_t pps_show_echo(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%d\n", !!info->echo); +} + +static ssize_t pps_show_name(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->name); +} + +static ssize_t pps_show_path(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->path); +} + +/* + * Files definitions + */ + +#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \ +{ \ + .attr = { \ + .name = __stringify(_name), \ + .mode = _mode, \ + .owner = THIS_MODULE, \ + }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute pps_class_device_attributes[] = { + DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL), + DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL), + DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL), + DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL), + DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL), + DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL), +}; + +/* + * Class definitions + */ + +static void pps_class_release(struct class_device *cdev) +{ + /* Nop??? */ +} + +static struct class pps_class = { + .name = "pps", + .release = pps_class_release, +}; + +/* + * Public functions + */ + +void pps_sysfs_remove_source_entry(struct pps_source_info_s *info) +{ + int i; + + /* Sanity checks */ + if (info == NULL) + return; + + /* Delete info files */ + if (info->mode&PPS_CAPTUREASSERT) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[0]); + + if (info->mode&PPS_CAPTURECLEAR) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[1]); + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + /* Deregister the pps class */ + class_device_unregister(&info->class_dev); +} + +int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id) +{ + char buf[32]; + int i, ret; + + /* Sanity checks */ + if (info == NULL || id >= PPS_MAX_SOURCES) + return -EINVAL; + + /* Create dir class device name */ + sprintf(buf, "%.02d", id); + + /* Setup the class struct */ + memset(&info->class_dev, 0, sizeof(struct class_device)); + info->class_dev.class = &pps_class; + strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN); + class_set_devdata(&info->class_dev, &pps_source[id]); + + /* Register the new class */ + ret = class_device_register(&info->class_dev); + if (unlikely(ret)) + goto error_class_device_register; + + /* Create info files */ + + /* Create file "assert" and "clear" according to source capability */ + if (info->mode & PPS_CAPTUREASSERT) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[0]); + i = 0; + if (unlikely(ret)) + goto error_class_device_create_file; + } + if (info->mode & PPS_CAPTURECLEAR) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[1]); + i = 1; + if (unlikely(ret)) + goto error_class_device_create_file; + } + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[i]); + if (unlikely(ret)) + goto error_class_device_create_file; + } + + return 0; + +error_class_device_create_file: + while (--i >= 0) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + class_device_unregister(&info->class_dev); + /* Here the release() method was already called */ + +error_class_device_register: + + return ret; +} + +void pps_sysfs_unregister(void) +{ + class_unregister(&pps_class); +} + +int pps_sysfs_register(void) +{ + return class_register(&pps_class); +} diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c index c84dab0..0c9a307 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 326020f..4a9906f 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -633,6 +634,52 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR, + -1 /* PPS ID is up to the system */); + if (ret < 0) { + pps_err("cannot register PPS source \"%s\"", state->pps_info.path); + return ret; + } + port->pps_source = ret; + pps_info("PPS source #%d \"%s\" added to the system ", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(&state->pps_info); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, state->pps_info.path); +} + +#else + +#define uart_register_pps_port(state, port) do { } while (0) +#define uart_unregister_pps_port(state, port) do { } while (0) + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -807,11 +854,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2100,6 +2155,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2349,6 +2410,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h index e84ace1..36746dc 100644 --- a/include/asm-i386/unistd.h +++ b/include/asm-i386/unistd.h @@ -329,10 +329,15 @@ #define __NR_signalfd 321 #define __NR_timerfd 322 #define __NR_eventfd 323 +#define __NR_time_pps_cmd 324 +#define __NR_time_pps_getparams 325 +#define __NR_time_pps_setparams 326 +#define __NR_time_pps_getcap 327 +#define __NR_time_pps_fetch 328 #ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 329 #define __ARCH_WANT_IPC_PARSE_VERSION #define __ARCH_WANT_OLD_READDIR diff --git a/include/linux/Kbuild b/include/linux/Kbuild index f317c27..a10d20a 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -293,6 +293,7 @@ unifdef-y += pmu.h unifdef-y += poll.h unifdef-y += ppp_defs.h unifdef-y += ppp-comp.h +unifdef-y += pps.h unifdef-y += ptrace.h unifdef-y += qnx4_fs.h unifdef-y += quota.h diff --git a/include/linux/parport.h b/include/linux/parport.h index 9cdd694..f53d9f4 100644 --- a/include/linux/parport.h +++ b/include/linux/parport.h @@ -100,6 +100,7 @@ typedef enum { #include <linux/proc_fs.h> #include <linux/spinlock.h> #include <linux/wait.h> +#include <linux/pps.h> #include <asm/system.h> #include <asm/ptrace.h> #include <asm/semaphore.h> @@ -327,6 +328,11 @@ struct parport { struct list_head full_list; struct parport *slaves[3]; + +#ifdef CONFIG_PPS_CLIENT_LP + struct pps_source_info_s pps_info; + int pps_source; /* PPS source ID */ +#endif }; #define DEFAULT_SPIN_TIME 500 /* us */ @@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode); /* Lowlevel drivers _can_ call this support function to handle irqs. */ static __inline__ void parport_generic_irq(int irq, struct parport *port) { +#ifdef CONFIG_PPS_CLIENT_LP + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("parport_pc: PPS assert event at %lu on source #%d", + jiffies, port->pps_source); +#endif + parport_ieee1284_interrupt (irq, port); read_lock(&port->cad_lock); if (port->cad && port->cad->irq_func) diff --git a/include/linux/pps.h b/include/linux/pps.h new file mode 100644 index 0000000..be32d16 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,207 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +/* Implementation note: the logical states ``assert'' and ``clear'' + * are implemented in terms of the chip register, i.e. ``assert'' + * means the bit is set. */ + +/* + * 3.2 New data structures + */ + +#ifndef __KERNEL__ +#include <asm/types.h> +#include <sys/time.h> +#else +#include <linux/time.h> +#endif + +#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */ +#define PPS_API_VERS PPS_API_VERS_2 +#define LINUXPSS_API 1 /* mark LinuxPPS API */ + +#define PPS_MAX_NAME_LEN 32 + +struct pps_ktime { + __u64 sec; + __u32 nsec; +}; + +struct pps_kinfo { + __u32 assert_sequence; /* seq. num. of assert event */ + __u32 clear_sequence; /* seq. num. of clear event */ + struct pps_ktime assert_tu; /* time of assert event */ + struct pps_ktime clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_kparams { + int api_version; /* API version # */ + int mode; /* mode bits */ + struct pps_ktime assert_off_tu; /* offset compensation for assert */ + struct pps_ktime clear_off_tu; /* offset compensation for clear */ +}; + +/* + * 3.3 Mode bit definitions + */ + +/* Device/implementation parameters */ +#define PPS_CAPTUREASSERT 0x01 /* capture assert events */ +#define PPS_CAPTURECLEAR 0x02 /* capture clear events */ +#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */ + +#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */ +#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */ + +#define PPS_CANWAIT 0x100 /* can we wait for an event? */ +#define PPS_CANPOLL 0x200 /* bit reserved for future use */ + +/* Kernel actions */ +#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */ +#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */ + +/* Timestamp formats */ +#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */ +#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */ + +/* + * 3.4.4 New functions: disciplining the kernel timebase + */ + +/* Kernel consumers */ +#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */ +#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to + use a phase-locked loop */ +#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to + use a frequency-locked loop */ +/* + * Here begins the implementation-specific part! + */ + +#include <linux/ioctl.h> + +struct pps_source_data_s { + int source; + char name[PPS_MAX_NAME_LEN]; + char path[PPS_MAX_NAME_LEN]; +}; + +#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *) +#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *) + +#ifdef __KERNEL__ + +#include <linux/device.h> + +/* + * Misc macros + */ + +#define PPS_VERSION "4.0.0-rc4" + +#ifdef CONFIG_PPS_DEBUG +#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#else +#define pps_dbg(format, arg...) do {} while (0) +#endif + +#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) + +/* + * Global defines + */ + +#define PPS_MAX_SOURCES 16 + +/* The specific PPS source info */ +struct pps_source_info_s { + char name[PPS_MAX_NAME_LEN]; /* simbolic name */ + char path[PPS_MAX_NAME_LEN]; /* path of connected device */ + int mode; /* PPS's allowed mode */ + + void (*echo)(int source, int event, void *data);/* the PPS echo function */ + + /* sysfs section */ + struct class_device class_dev; +}; + +/* The main struct */ +struct pps_s { + struct pps_source_info_s *info; /* PSS source info */ + + struct pps_kparams params; /* PPS's current params */ + + volatile __u32 assert_sequence; /* PPS' assert event seq # */ + volatile __u32 clear_sequence; /* PPS' clear event seq # */ + volatile struct pps_ktime assert_tu; + volatile struct pps_ktime clear_tu; + int current_mode; /* PPS mode at event time */ + + int go; /* PPS event is arrived? */ + wait_queue_head_t queue; /* PPS event queue */ +}; + +/* + * Global variables + */ + +extern struct pps_s pps_source[PPS_MAX_SOURCES]; +extern struct mutex pps_mutex; +extern struct pps_source_info_s dummy_info; + +/* + * Global functions + */ + +static inline int pps_is_allocated(int source) +{ + return pps_source[source].info != &dummy_info; +} + +#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev) + +/* + * Exported functions + */ + +extern int pps_register_source(struct pps_source_info_s *info, + int default_params, int try_id); +extern void pps_unregister_source(struct pps_source_info_s *info); +extern void pps_event(int source, int event, void *data); + +extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info, + int id); +extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info); +extern int pps_sysfs_register(void); +extern void pps_sysfs_unregister(void); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 7f2c99d..ba4503e 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -153,6 +153,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -232,6 +233,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -276,7 +280,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -308,6 +313,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info_s pps_info; +#endif + struct mutex mutex; }; @@ -472,13 +481,27 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; +#ifdef CONFIG_PPS_CLIENT_UART + struct tty_driver *drv = port->info->tty->driver; -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("%s%d: PPS assert event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } + else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + pps_dbg("%s%d: PPS clear event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 83d0ec1..bfc8899 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -65,6 +65,7 @@ struct getcpu_cache; #include <asm/signal.h> #include <linux/quota.h> #include <linux/key.h> +#include <linux/pps.h> asmlinkage long sys_time(time_t __user *tloc); asmlinkage long sys_stime(time_t __user *tptr); @@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags, const struct itimerspec __user *utmr); asmlinkage long sys_eventfd(unsigned int count); +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg); +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params); +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params); +asmlinkage long sys_time_pps_getcap(int source, int __user *mode); +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout); + int kernel_execve(const char *filename, char *const argv[], char *const envp[]); #endif diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 7e11e2c..e0fccc2 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -148,3 +148,10 @@ cond_syscall(sys_timerfd); cond_syscall(compat_sys_signalfd); cond_syscall(compat_sys_timerfd); cond_syscall(sys_eventfd); + +/* PPS dependent */ +cond_syscall(sys_time_pps_find); +cond_syscall(sys_time_pps_getparams); +cond_syscall(sys_time_pps_setparams); +cond_syscall(sys_time_pps_getcap); +cond_syscall(sys_time_pps_fetch); ^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-17 18:05 [PATCH] LinuxPPS - definitive version Rodolfo Giometti @ 2007-07-23 13:35 ` David Woodhouse 2007-07-23 16:04 ` Rodolfo Giometti ` (2 more replies) 0 siblings, 3 replies; 43+ messages in thread From: David Woodhouse @ 2007-07-23 13:35 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton On Tue, 2007-07-17 at 20:05 +0200, Rodolfo Giometti wrote: > Hello, > > here my last patch for PPS support. > > In my opinion it should be ok for inclusion... please, let me know if > something should be still changed. s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt Please feed it to scripts/checkpatch.pl -- you can ignore all the warnings about lines greater than 80 characters, and the complete crap about "declaring multiple variables together should be avoided", but some of what it points out is valid. Including the one about 'volatile' -- your explanation lacked credibility. If you really need 'volatile' then put it at the places you actually need it; not the declaration of the structure. You've also reverted to structures which vary between 32-bit and 64-bit userspace, because they use 'long' and 'struct timespec', but you haven't provided the compat_* routines which are then necessary. +typedef int pps_handle_t; /* represents a PPS source */ +typedef unsigned long pps_seq_t; /* sequence number */ +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s tamps */ +typedef struct pps_info pps_info_t; +typedef struct pps_params pps_params_t; Don't do this for the structures. It's dubious enough for the integer types. -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-23 13:35 ` David Woodhouse @ 2007-07-23 16:04 ` Rodolfo Giometti 2007-07-23 19:28 ` Andrew Morton 2007-07-24 8:00 ` Rodolfo Giometti 2 siblings, 0 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-23 16:04 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote: > > s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt Fixed. > Please feed it to scripts/checkpatch.pl -- you can ignore all the > warnings about lines greater than 80 characters, and the complete crap > about "declaring multiple variables together should be avoided", but > some of what it points out is valid. Including the one about 'volatile' Ok, I'll do it. > -- your explanation lacked credibility. If you really need 'volatile' > then put it at the places you actually need it; not the declaration of > the structure. About this debate, please, take a look at the pps_event() function: void pps_event(int source, int event, void *data) { struct timespec __ts; struct pps_ktime ts; /* First of all we get the time stamp... */ getnstimeofday(&__ts); /* ... and translate it to PPS time data struct */ ts.sec = __ts.tv_sec; ts.nsec = __ts.tv_nsec; if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { pps_err("unknow event (%x) for source %d", event, source); return; } /* We wish not using locks at all into this function... a possible * solution is to check the "info" field against the pointer to * "dummy_info". * If "info" points to "dummy_info" we can return doing nothing since, * even if a new PPS source is registered by another CPU we can * safely not register current event. * If "info" points to a valid PPS source's info data we can continue * without problem since, even if current PPS source is deregistered * by another CPU, we still continue writing data into a valid area * (dummy_info). */ if (pps_source[source].info == &dummy_info) return; /* Must call the echo function? */ if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) pps_source[source].info->echo(source, event, data); /* Check the event */ pps_source[source].current_mode = pps_source[source].params.mode; if (event & PPS_CAPTUREASSERT) { /* We have to add an offset? */ if (pps_source[source].params.mode & PPS_OFFSETASSERT) pps_add_offset(&ts, &pps_source[source].params.assert_off_tu); /* Save the time stamp */ pps_source[source].assert_tu = ts; pps_source[source].assert_sequence++; pps_dbg("capture assert seq #%u for source %d", pps_source[source].assert_sequence, source); } if (event & PPS_CAPTURECLEAR) { /* We have to add an offset? */ if (pps_source[source].params.mode & PPS_OFFSETCLEAR) pps_add_offset(&ts, &pps_source[source].params.clear_off_tu); /* Save the time stamp */ pps_source[source].clear_tu = ts; pps_source[source].clear_sequence++; pps_dbg("capture clear seq #%u for source %d", pps_source[source].clear_sequence, source); } pps_source[source].go = ~0; wake_up_interruptible(&pps_source[source].queue); } The problems should arise at: if (pps_source[source].info == &dummy_info) return; but as explained into the comment there should be no problems at all... About "where" to put the "volatile" attribute I don't understand what you mean... such attribute is needed (IMHO) for "assert_sequence"&C, where should I put it? :-o > You've also reverted to structures which vary between 32-bit and 64-bit > userspace, because they use 'long' and 'struct timespec', but you > haven't provided the compat_* routines which are then necessary. As already suggested I used fixed size variables. See the new struct "struct pps_ktime". > +typedef int pps_handle_t; /* represents a PPS source */ > +typedef unsigned long pps_seq_t; /* sequence number */ > +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ > +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s > tamps */ > +typedef struct pps_info pps_info_t; > +typedef struct pps_params pps_params_t; > > Don't do this for the structures. It's dubious enough for the integer > types. Such code is for userland since RFC2783 requires such types... I moved all userland code into Documentation/pps/timepps.h which can be used by userland programs whose require RFC compatibility. I'll post a new patch ASAP. Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-23 13:35 ` David Woodhouse 2007-07-23 16:04 ` Rodolfo Giometti @ 2007-07-23 19:28 ` Andrew Morton 2007-07-23 19:48 ` David Woodhouse 2007-07-24 8:00 ` Rodolfo Giometti 2 siblings, 1 reply; 43+ messages in thread From: Andrew Morton @ 2007-07-23 19:28 UTC (permalink / raw) To: David Woodhouse; +Cc: Rodolfo Giometti, linux-kernel On Mon, 23 Jul 2007 14:35:16 +0100 David Woodhouse <dwmw2@infradead.org> wrote: > Please feed it to scripts/checkpatch.pl -- you can ignore all the > warnings about lines greater than 80 characters, and the complete crap > about "declaring multiple variables together should be avoided", but > some of what it points out is valid. The above are David's opinions. Many, probably most kernel developers do not agree with them. And there are good reasons for ignoring David's opinions here. To understand those reasons, try looking at some MTD code. ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-23 19:28 ` Andrew Morton @ 2007-07-23 19:48 ` David Woodhouse 0 siblings, 0 replies; 43+ messages in thread From: David Woodhouse @ 2007-07-23 19:48 UTC (permalink / raw) To: Andrew Morton; +Cc: Rodolfo Giometti, linux-kernel On Mon, 2007-07-23 at 12:28 -0700, Andrew Morton wrote: > On Mon, 23 Jul 2007 14:35:16 +0100 > David Woodhouse <dwmw2@infradead.org> wrote: > > > Please feed it to scripts/checkpatch.pl -- you can ignore all the > > warnings about lines greater than 80 characters, and the complete crap > > about "declaring multiple variables together should be avoided", but > > some of what it points out is valid. > > The above are David's opinions. Many, probably most kernel developers do not > agree with them. Linus called the 80-column thing a 'Nazi dream' and I'm inclined to agree with him. It's something to bear in mind, of course, but sometimes it's best ignored. And the 'declaring multiple variables together' is something I've _never_ heard of. Might be applicable if you're actually giving them initial values, but just declaring them together is fine, surely? -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-23 13:35 ` David Woodhouse 2007-07-23 16:04 ` Rodolfo Giometti 2007-07-23 19:28 ` Andrew Morton @ 2007-07-24 8:00 ` Rodolfo Giometti 2007-07-24 13:49 ` David Woodhouse 2 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-24 8:00 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton [-- Attachment #1: Type: text/plain, Size: 1902 bytes --] On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote: > > s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt Fixed. > Please feed it to scripts/checkpatch.pl -- you can ignore all the > warnings about lines greater than 80 characters, and the complete crap > about "declaring multiple variables together should be avoided", but Done. Most fixed. > some of what it points out is valid. Including the one about 'volatile' > -- your explanation lacked credibility. If you really need 'volatile' > then put it at the places you actually need it; not the declaration of > the structure. Can you please explain better where should I put the 'volatile' attribute? :-o > You've also reverted to structures which vary between 32-bit and 64-bit > userspace, because they use 'long' and 'struct timespec', but you > haven't provided the compat_* routines which are then necessary. This should be not needed due new 'struct pps_ktime'. > +typedef int pps_handle_t; /* represents a PPS source */ > +typedef unsigned long pps_seq_t; /* sequence number */ > +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ > +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time s > tamps */ > +typedef struct pps_info pps_info_t; > +typedef struct pps_params pps_params_t; > > Don't do this for the structures. It's dubious enough for the integer > types. These typedefs are into timepps.h which is an userland file (located into Documentation/pps/) and are requested by the RFC. Attached you can find my last patch. Thanks again, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 [-- Attachment #2: ntp-pps-2.6.22-bis.diff --] [-- Type: text/plain, Size: 68285 bytes --] diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..a2660a2 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest ppsctl + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section ---------------------------------------------------------- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section ------------------------------------------------------------ + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt new file mode 100644 index 0000000..511fa36 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,211 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you change the original RFC 2783: + + pps_handle_t type is an opaque __scalar type__ used to represent a + PPS source within the API + +into a modified: + + pps_handle_t type is an opaque __variable__ used to represent a PPS + source within the API and programs should not access it directly to + it due to its opacity. + +This change seems to be neglibile because even the original RFC 2783 +does not encourage programs to check (read: use) the pps_handle_t +variable before calling the time_pps_*() functions, since each +function should do this job internally. + +If I intentionally separate the concept of "file descriptor" from the +concept of the "PPS source" I'm obliged to provide a solution to find +and register a PPS-source without using a file descriptor: it's done +by the functions time_pps_findsource() and time_pps_findpath() now. + +According to this current NTPD drivers' code should be modified as +follows: + ++#ifdef PPS_HAVE_FINDPATH ++ /* Get the PPS source's real name */ ++ fd = readlink(link, path, STRING_LEN-1); ++ if (fd <= 0) ++ strncpy(path, link, STRING_LEN); ++ else ++ path[fd] = '\0'; ++ ++ /* Try to find the source */ ++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); ++ if (fd < 0) { ++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" " ++ "in the system", path); ++ return 1; ++ } ++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"", ++ fd, path, id); ++#endif /* PPS_HAVE_FINDPATH */ ++ ++ + if (time_pps_create(fd, &pps_handle) < 0) { +- pps_handle = 0; + msyslog(LOG_ERR, "refclock: time_pps_create failed: %m"); + } + + +Coding example +-------------- + +To register a PPS source into the kernel you should define a struct +pps_source_info_s as follow: + + static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, + }; + +and then calling the function pps_register_source() in your +intialization routine as follow: + + source = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + +The pps_register_source() prototype is: + + int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) + +where "info" is a pointer to a structure that describes a particular +PPS source, "default_params" tells the system what the initial default +parameters for the device should be (is obvious that these parameters +must be a subset of ones defined into the struct +pps_source_info_s which describe the capabilities of the driver) +and "try_id" can be used to force a particular ID for your device into +the system (just use -1 if you wish the system chooses one for you). + +Once you have registered a new PPS source into the system you can +signal an assert event (for example in the interrupt handler routine) +just using: + + pps_event(source, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for an example code. + + +SYSFS support +------------- + +The SYSFS support is enabled by default if the SYSFS filesystem is +enabled in the kernel and it provides a new class: + + $ ls /sys/class/pps/ + 00/ 01/ 02/ + +Every directory is the ID of a PPS sources defined into the system and +inside you find several files: + + $ ls /sys/class/pps/00/ + assert clear echo mode name path subsystem@ uevent + +Inside each "assert" and "clear" file you can find the timestamp and a +sequence number: + + $ cat /sys/class/pps/00/assert + 1170026870.983207967#8 + +Where before the "#" is the timestamp in seconds and after it is the +sequence number. Other files are: + +* echo: reports if the PPS source has an echo function or not; + +* mode: reports available PPS functioning modes; + +* name: reports the PPS source's name; + +* path: reports the PPS source's device path, that is the device the + PPS source is connected to (if it exists). + + +Testing the PPS support +----------------------- + +In order to test the PPS support even without specific hardware you can use +the ktimer driver (see the client subsection in the PPS configuration menu) +and the userland tools provided into Documentaion/pps/ directory. + +Once you have enabled the compilation of ktimer just modprobe it (if +not statically compiled): + + # modprobe ktimer + +and the run ppstest as follow: + + $ ./ppstest + found PPS source #0 "ktimer" on "" + ok, found 1 source(s), now start fetching data... + source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0 + source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0 + +Please, note that to compile userland programs you need the file timepps.h +(see Documentation/pps/). diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c new file mode 100644 index 0000000..17afcbd --- /dev/null +++ b/Documentation/pps/ppsctl.c @@ -0,0 +1,61 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <string.h> +#include <linux/serial.h> + +void usage(char *name) +{ + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name); + + exit(EXIT_FAILURE); +} + +int main(int argc, char *argv[]) +{ + int fd, ret; + struct serial_struct ss; + + if (argc < 2) + usage(argv[0]); + + fd = open(argv[1], O_RDWR); + if (fd < 0) { + perror("open"); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCGSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCGSERIAL)"); + exit(EXIT_FAILURE); + } + + if (argc < 3) { /* just read PPS status */ + printf("PPS is %sabled\n", + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis"); + exit(EXIT_SUCCESS); + } + + if (argv[2][0] == 'e' || argv[2][0] == '1') + ss.flags |= ASYNC_HARDPPS_CD; + else if (argv[2][0] == 'd' || argv[2][0] == '0') + ss.flags &= ~ASYNC_HARDPPS_CD; + else { + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCSSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCSSERIAL)"); + exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c new file mode 100644 index 0000000..bfd1064 --- /dev/null +++ b/Documentation/pps/ppstest.c @@ -0,0 +1,201 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <timepps.h> + +#define STRING_LEN PPS_MAX_NAME_LEN + +int find_source(int try_link, char *link, pps_handle_t *handle, + int *avail_mode) +{ + int num = -1; + char id[STRING_LEN] = "", /* no ID string by default */ + path[STRING_LEN]; + pps_params_t params; + int ret; + + if (try_link) { + printf("trying PPS source \"%s\"\n", link); +#ifdef PPS_HAVE_FINDPATH + /* Get the PPS source's real name */ + time_pps_readlink(link, STRING_LEN, path, STRING_LEN); + + /* Try to find the source by using the supplied "path" name */ + ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); + if (ret < 0) + goto exit; + num = ret; +#else +#warning "cannot use time_pps_findpath()" + ret = -1; +#endif /* PPS_HAVE_FINDPATH */ + } +#ifdef PPS_HAVE_FINDSOURCE + /* Try to find the source (by using "index = -1" we ask just + * for a generic source) */ + ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN); +#else +#warning "cannot use time_pps_findsource()" + ret = -1; +#endif /* PPS_HAVE_FINDSOURCE */ + if (ret < 0) { +exit: + fprintf(stderr, "no available PPS source in the system\n"); + return -1; + } + num = ret; + printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path); + + /* If "path" is not NULL we should *at least* open the pointed + * device in order to enable the interrupts generation. + * Note that this can be NOT enough anyway, infact you may need sending + * additional commands to your GPS antenna before it starts sending + * the PPS signal. */ + if (strlen(path)) { + ret = open(path, O_RDWR); + if (ret < 0) { + fprintf(stderr, "cannot open \"%s\" (%m)\n", path); + return -1; + } + } + + /* Open the PPS source */ + ret = time_pps_create(num, handle); + if (ret < 0) { + fprintf(stderr, "cannot create a PPS source (%m)\n"); + return -1; + } + + /* Find out what features are supported */ + ret = time_pps_getcap(*handle, avail_mode); + if (ret < 0) { + fprintf(stderr, "cannot get capabilities (%m)\n"); + return -1; + } + if ((*avail_mode & PPS_CAPTUREASSERT) == 0) { + fprintf(stderr, "cannot CAPTUREASSERT\n"); + return -1; + } + if ((*avail_mode & PPS_OFFSETASSERT) == 0) { + fprintf(stderr, "cannot OFFSETASSERT\n"); + return -1; + } + + /* Capture assert timestamps, and compensate for a 675 nsec + * propagation delay */ + ret = time_pps_getparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot get parameters (%m)\n"); + return -1; + } + params.assert_offset.tv_sec = 0; + params.assert_offset.tv_nsec = 675; + params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT; + ret = time_pps_setparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot set parameters (%m)\n"); + return -1; + } + + return 0; +} + +int fetch_source(int i, pps_handle_t *handle, int *avail_mode) +{ + struct timespec timeout; + pps_info_t infobuf; + int ret; + + /* create a zero-valued timeout */ + timeout.tv_sec = 3; + timeout.tv_nsec = 0; + +retry: + if (*avail_mode & PPS_CANWAIT) { + /* waits for the next event */ + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } else { + sleep(1); + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } + if (ret < 0) { + if (ret == -EINTR) { + fprintf(stderr, "time_pps_fetch() got a signal!\n"); + goto retry; + } + + fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret); + return -1; + } + + printf("source %d - " + "assert %ld.%09ld, sequence: %ld - " + "clear %ld.%09ld, sequence: %ld\n", + i, + infobuf.assert_timestamp.tv_sec, + infobuf.assert_timestamp.tv_nsec, + infobuf.assert_sequence, + infobuf.clear_timestamp.tv_sec, + infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int num, try_link = 0; /* by default use findsource */ + char link[STRING_LEN] = "/dev/gps0"; /* just a default device */ + pps_handle_t handle[4]; + int avail_mode[4]; + int i = 0, ret; + + if (argc == 1) { + ret = find_source(try_link, link, &handle[0], &avail_mode[0]); + if (ret < 0) + exit(EXIT_FAILURE); + + num = 1; + } else { + for (i = 1; i < argc && i <= 4; i++) { + ret = sscanf(argv[i], "%d", &num); + if (ret < 1) { + try_link = ~0; + strncpy(link, argv[i], STRING_LEN); + } + + ret = + find_source(try_link, link, &handle[i - 1], + &avail_mode[i - 1]); + if (ret < 0) + exit(EXIT_FAILURE); + } + + num = i - 1; + } + + printf("ok, found %d source(s), now start fetching data...\n", num); + + /* loop, printing the most recent timestamp every second or so */ + while (1) { + for (i = 0; i < num; i++) { + ret = fetch_source(i, &handle[i], &avail_mode[i]); + if (ret < 0 && errno != ETIMEDOUT) + exit(EXIT_FAILURE); + } + } + + for (; i >= 0; i--) + time_pps_destroy(handle[i]); + + return 0; +} diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h new file mode 100644 index 0000000..dee1782 --- /dev/null +++ b/Documentation/pps/timepps.h @@ -0,0 +1,234 @@ +/* + * timepps.h -- PPS API main header + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +/* + * New data structures + */ + +struct ntp_fp { + unsigned int integral; + unsigned int fractional; +}; + +union pps_timeu { + struct timespec tspec; + struct ntp_fp ntpfp; + unsigned long longpad[3]; +}; + +struct pps_info { + unsigned long assert_sequence; /* seq. num. of assert event */ + unsigned long clear_sequence; /* seq. num. of clear event */ + union pps_timeu assert_tu; /* time of assert event */ + union pps_timeu clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_params { + int api_version; /* API version # */ + int mode; /* mode bits */ + union pps_timeu assert_off_tu; /* offset compensation for assert */ + union pps_timeu clear_off_tu; /* offset compensation for clear */ +}; + +typedef int pps_handle_t; /* represents a PPS source */ +typedef unsigned long pps_seq_t; /* sequence number */ +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */ +typedef struct pps_info pps_info_t; +typedef struct pps_params pps_params_t; + +#define assert_timestamp assert_tu.tspec +#define clear_timestamp clear_tu.tspec + +#define assert_timestamp_ntpfp assert_tu.ntpfp +#define clear_timestamp_ntpfp clear_tu.ntpfp + +#define assert_offset assert_off_tu.tspec +#define clear_offset clear_off_tu.tspec + +#define assert_offset_ntpfp assert_off_tu.ntpfp +#define clear_offset_ntpfp clear_off_tu.ntpfp + +/* + * The PPS API + */ + +#define PPS_HAVE_FINDSOURCE 1 +#define pps_min(a, b) (a) < (b) ? a : b +int time_pps_findsource(int index, char *path, int pathlen, char *idstring, + int idlen) +{ + struct pps_source_data_s data; + int ret; + + data.source = index; + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +/* Defined iff PPS_HAVE_FINDPATH is defined */ +void time_pps_readlink(char *link, int linklen, char *path, int pathlen) +{ + int i; + + i = readlink(link, path, pathlen - 1); + if (i <= 0) { + /* "link" is not a valid symbolic so we directly use it */ + strncpy(path, link, linklen <= pathlen ? linklen : pathlen); + return; + } + + /* Return the file name where "link" points to */ + path[i] = '\0'; +} + +#define PPS_HAVE_FINDPATH 1 +int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen) +{ + struct pps_source_data_s data; + int ret; + + strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +int time_pps_create(int source, pps_handle_t *handle) +{ + if (!handle) { + errno = EINVAL; + return -1; + } + + /* In LinuxPPS there are no differences between a PPS source and + * a PPS handle so we return the same value. + */ + *handle = source; + + return 0; +} + +int time_pps_destroy(pps_handle_t handle) +{ + /* Nothing to destroy here */ + + return 0; +} + +int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams) +{ + int ret; + struct pps_kparams __ppsparams; + + ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams); + + ppsparams->api_version = __ppsparams.api_version; + ppsparams->mode = __ppsparams.mode; + ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec; + ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec; + ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec; + ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec; + + return ret; +} + +int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams) +{ + struct pps_kparams __ppsparams; + + __ppsparams.api_version = ppsparams->api_version; + __ppsparams.mode = ppsparams->mode; + __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec; + __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec; + __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec; + __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec; + + return syscall(__NR_time_pps_getparams, handle, &__ppsparams); +} + +/* Get capabilities for handle */ +int time_pps_getcap(pps_handle_t handle, int *mode) +{ + return syscall(__NR_time_pps_getcap, handle, mode); +} + +int time_pps_fetch(pps_handle_t handle, const int tsformat, + pps_info_t *ppsinfobuf, const struct timespec *timeout) +{ + struct pps_kinfo __ppsinfobuf; + struct pps_ktime __timeout; + int ret; + + /* Sanity checks */ + if (tsformat != PPS_TSFMT_TSPEC) { + errno = EINVAL; + return -1; + } + + if (timeout) { + __timeout.sec = timeout->tv_sec; + __timeout.nsec = timeout->tv_nsec; + } + + ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf, + timeout ? &__timeout : NULL); + + ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence; + ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence; + ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec; + ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec; + ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec; + ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec; + ppsinfobuf->current_mode = __ppsinfobuf.current_mode; + + return ret; +} + +int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer, + const int edge, const int tsformat) +{ + /* LinuxPPS doesn't implement kernel consumer feature */ + errno = EOPNOTSUPP; + return -1; +} + +#endif /* _SYS_TIMEPPS_H_ */ diff --git a/MAINTAINERS b/MAINTAINERS index df40a4e..17e9a02 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2903,6 +2903,13 @@ P: Michal Ostrowski M: mostrows@speakeasy.net S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S index bf6adce..f1bf4ff 100644 --- a/arch/i386/kernel/syscall_table.S +++ b/arch/i386/kernel/syscall_table.S @@ -323,3 +323,8 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_time_pps_cmd + .long sys_time_pps_getparams /* 325 */ + .long sys_time_pps_setparams + .long sys_time_pps_getcap + .long sys_time_pps_fetch diff --git a/drivers/Kconfig b/drivers/Kconfig index 050323f..bb54cab 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig" source "drivers/spi/Kconfig" +source "drivers/pps/Kconfig" + source "drivers/w1/Kconfig" source "drivers/hwmon/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index adad2f3..985d495 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_I2O) += message/ obj-$(CONFIG_RTC_LIB) += rtc/ obj-y += i2c/ +obj-$(CONFIG_PPS) += pps/ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/ obj-$(CONFIG_PHONE) += telephony/ diff --git a/drivers/char/lp.c b/drivers/char/lp.c index 62051f8..403753f 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -746,6 +746,27 @@ static struct console lpcons = { #endif /* console on line printer */ +/* Support for PPS signal on the line printer */ + +#ifdef CONFIG_PPS_CLIENT_LP + +static void lp_pps_echo(int source, int event, void *data) +{ + struct parport *port = data; + unsigned char status = parport_read_status(port); + + /* echo event via SEL bit */ + parport_write_control(port, + parport_read_control(port) | PARPORT_CONTROL_SELECT); + + /* signal no event */ + if ((status & PARPORT_STATUS_ACK) != 0) + parport_write_control(port, + parport_read_control(port) & ~PARPORT_CONTROL_SELECT); +} + +#endif + /* --- initialisation code ------------------------------------- */ static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC }; @@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port) } #endif +#ifdef CONFIG_PPS_CLIENT_LP + snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr); + + /* No PPS support if lp port has no IRQ line */ + if (port->irq != PARPORT_IRQ_NONE) { + strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN); + + port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + port->pps_info.echo = lp_pps_echo; + + port->pps_source = pps_register_source(&(port->pps_info), + PPS_CAPTUREASSERT | PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (port->pps_source < 0) + pps_err("cannot register PPS source \"%s\"", + port->pps_info.path); + else + pps_info("PPS source #%d \"%s\" added to the system", + port->pps_source, port->pps_info.path); + } else { + port->pps_source = -1; + pps_err("PPS support disabled due port \"%s\" is in polling mode", + port->pps_info.path); + } +#endif + return 0; } @@ -860,6 +910,14 @@ static void lp_detach (struct parport *port) console_registered = NULL; } #endif /* CONFIG_LP_CONSOLE */ + +#ifdef CONFIG_PPS_CLIENT_LP + if (port->pps_source >= 0) { + pps_unregister_source(&(port->pps_info)); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, port->pps_info.path); + } +#endif } static struct parport_driver lp_driver = { diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig new file mode 100644 index 0000000..a00b59a --- /dev/null +++ b/drivers/pps/Kconfig @@ -0,0 +1,31 @@ +# +# PPS support configuration +# + +menu "PPS support" + +config PPS + bool "PPS support" + depends on EXPERIMENTAL + ---help--- + PPS (Pulse Per Second) is a special pulse provided by some GPS + antennae. Userland can use it to get an high time reference. + + Some antennae's PPS signals are connected with the CD (Carrier + Detect) pin of the serial line they use to communicate with the + host. In this case use the SERIAL_LINE client support. + + Some antennae's PPS signals are connected with some special host + inputs so you have to enable the corresponding client support. + +config PPS_DEBUG + bool "PPS debugging messages" + depends on PPS + help + Say Y here if you want the PPS support to produce a bunch of debug + messages to the system log. Select this if you are having a + problem with PPS support and want to see more of what is going on. + +source drivers/pps/clients/Kconfig + +endmenu diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile new file mode 100644 index 0000000..76101cd --- /dev/null +++ b/drivers/pps/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the PPS core. +# + +pps_core-objs += pps.o kapi.o sysfs.o +obj-$(CONFIG_PPS) += pps_core.o +obj-y += clients/ diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig new file mode 100644 index 0000000..58a1e55 --- /dev/null +++ b/drivers/pps/clients/Kconfig @@ -0,0 +1,30 @@ +# +# PPS clients configuration +# + +if PPS + +comment "PPS clients support" + +config PPS_CLIENT_KTIMER + tristate "Kernel timer client (Testing client, use for debug)" + help + If you say yes here you get support for a PPS debugging client + which uses a kernel timer to generate the PPS signal. + + This driver can also be built as a module. If so, the module + will be called ktimer.ko. + +config PPS_CLIENT_UART + bool "UART serial support" + help + If you say yes here you get support for a PPS source connected + with the CD (Carrier Detect) pin of your serial port. + +config PPS_CLIENT_LP + bool "Parallel printer support" + help + If you say yes here you get support for a PPS source connected + with the interrupt pin of your parallel port. + +endif diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile new file mode 100644 index 0000000..10d1dfa --- /dev/null +++ b/drivers/pps/clients/Makefile @@ -0,0 +1,6 @@ +# +# Makefile for PPS clients. +# + +obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o + diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c new file mode 100644 index 0000000..efd6eba --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pps_info("PPS event at %lu", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pps_info("echo %s %s for source %d", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, +}; + +/* + * Module staff + */ + +static void __exit pps_ktimer_exit(void) +{ + del_timer_sync(&ktimer); + pps_unregister_source(&pps_ktimer_info); + + pps_info("ktimer PPS source unregistered"); +} + +static int __init pps_ktimer_init(void) +{ + int ret; + + ret = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (ret < 0) { + pps_err("cannot register ktimer source"); + return ret; + } + source = ret; + + setup_timer(&ktimer, pps_ktimer_event, 0); + mod_timer(&ktimer, jiffies + HZ); + + pps_info("ktimer PPS source registered at %d", source); + + return 0; +} + +module_init(pps_ktimer_init); +module_exit(pps_ktimer_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c new file mode 100644 index 0000000..19c21e5 --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,215 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/pps.h> + +/* + * Local functions + */ + +static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset) +{ + ts->nsec += offset->nsec; + if (ts->nsec >= NSEC_PER_SEC) { + ts->nsec -= NSEC_PER_SEC; + ts->sec++; + } else if (ts->nsec < 0) { + ts->nsec += NSEC_PER_SEC; + ts->sec--; + } + ts->sec += offset->sec; +} + +/* + * Exported functions + */ + +int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) +{ + int i = -1, err = 0, ret; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + if (try_id >= 0) { + if (pps_is_allocated(try_id)) { + pps_err("source id %d busy", try_id); + err = -EBUSY; + goto pps_register_source_exit; + } + i = try_id; + } else { + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (!pps_is_allocated(i)) + break; + if (i >= PPS_MAX_SOURCES) { + pps_err("no free source ids"); + err = -ENOMEM; + goto pps_register_source_exit; + } + } + + /* Sanity checks */ + if ((info->mode & default_params) != default_params) { + pps_err("unsupported default parameters"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 && + info->echo == NULL) { + pps_err("echo function is not defined"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + pps_err("unspecified time format"); + err = -EINVAL; + goto pps_register_source_exit; + } + + /* Allocate the PPS source. + * + * Note that we should reset all fields BUT "info" one! */ + memset(&(pps_source[i].params), 0, sizeof(struct pps_kparams)); + pps_source[i].params.api_version = PPS_API_VERS; + pps_source[i].params.mode = default_params; + pps_source[i].assert_sequence = 0; + pps_source[i].clear_sequence = 0; + pps_source[i].current_mode = 0; + pps_source[i].go = 0; + init_waitqueue_head(&pps_source[i].queue); + + /* Allocate the PPS source */ + pps_source[i].info = info; + +pps_register_source_exit : + mutex_unlock(&pps_mutex); + + if (err < 0) + return err; + + ret = pps_sysfs_create_source_entry(info, i); + if (ret < 0) + pps_err("unable to create sysfs entry for source %d", i); + + return i; +} +EXPORT_SYMBOL(pps_register_source); + +void pps_unregister_source(struct pps_source_info_s *info) +{ + int i; + + pps_sysfs_remove_source_entry(info); + + if (mutex_lock_interruptible(&pps_mutex)) + return; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && pps_source[i].info == info) + break; + + if (i >= PPS_MAX_SOURCES) { + pps_err("warning! Try to unregister an unknow PPS source"); + goto pps_unregister_source_exit; + } + + /* Deallocate the PPS source */ + pps_source[i].info = &dummy_info; + +pps_unregister_source_exit : + mutex_unlock(&pps_mutex); +} +EXPORT_SYMBOL(pps_unregister_source); + +void pps_event(int source, int event, void *data) +{ + struct timespec __ts; + struct pps_ktime ts; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { + pps_err("unknow event (%x) for source %d", event, source); + return; + } + + /* We wish not using locks at all into this function... a possible + * solution is to check the "info" field against the pointer to + * "dummy_info". + * If "info" points to "dummy_info" we can return doing nothing since, + * even if a new PPS source is registered by another CPU we can + * safely not register current event. + * If "info" points to a valid PPS source's info data we can continue + * without problem since, even if current PPS source is deregistered + * by another CPU, we still continue writing data into a valid area + * (dummy_info). + */ + if (pps_source[source].info == &dummy_info) + return; + + /* Must call the echo function? */ + if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) + pps_source[source].info->echo(source, event, data); + + /* Check the event */ + pps_source[source].current_mode = pps_source[source].params.mode; + if (event & PPS_CAPTUREASSERT) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETASSERT) + pps_add_offset(&ts, + &pps_source[source].params.assert_off_tu); + + /* Save the time stamp */ + pps_source[source].assert_tu = ts; + pps_source[source].assert_sequence++; + pps_dbg("capture assert seq #%u for source %d", + pps_source[source].assert_sequence, source); + } + if (event & PPS_CAPTURECLEAR) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETCLEAR) + pps_add_offset(&ts, + &pps_source[source].params.clear_off_tu); + + /* Save the time stamp */ + pps_source[source].clear_tu = ts; + pps_source[source].clear_sequence++; + pps_dbg("capture clear seq #%u for source %d", + pps_source[source].clear_sequence, source); + } + + pps_source[source].go = ~0; + wake_up_interruptible(&pps_source[source].queue); +} +EXPORT_SYMBOL(pps_event); diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c new file mode 100644 index 0000000..9134823 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,398 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/version.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/linkage.h> +#include <linux/sched.h> +#include <linux/pps.h> +#include <linux/uaccess.h> + +/* + * Global variables + */ + +struct pps_s pps_source[PPS_MAX_SOURCES]; +DEFINE_MUTEX(pps_mutex); + +void dummy_echo(int source, int event, void *data) { } +struct pps_source_info_s dummy_info; /* Dummy PPS info for unallocated + PPS sources */ + +/* + * Misc functions + */ + +static inline int pps_check_source(int source) +{ + return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0; +} + +static int pps_find_source(int source) +{ + int i; + + if (source >= 0) { + if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source)) + return -EINVAL; + else + return source; + } + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +static int pps_find_path(char *path) +{ + int i; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && + (strncmp(pps_source[i].info->path, path, + PPS_MAX_NAME_LEN) == 0 || + strncmp(pps_source[i].info->name, path, + PPS_MAX_NAME_LEN) == 0)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +/* + * PPS System Calls + */ + +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg) +{ + struct pps_source_data_s data; + int ret = 0; + + pps_dbg("%s: cmd %d", __FUNCTION__, cmd); + + /* Sanity checks */ + if (_IOC_TYPE(cmd) != 'P') + return -EOPNOTSUPP; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + switch (cmd) { + case PPS_CMD_FIND_SRC : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source); + + data.source = pps_find_source(data.source); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + case PPS_CMD_FIND_PATH : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path); + + data.source = pps_find_path(data.path); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + default : + pps_err("invalid sys_time_pps_cmd %d", cmd); + ret = -EOPNOTSUPP; + goto sys_time_pps_cmd_exit; + } + + /* Found! So copy the info */ + strncpy(data.name, pps_source[data.source].info->name, + PPS_MAX_NAME_LEN); + strncpy(data.path, pps_source[data.source].info->path, + PPS_MAX_NAME_LEN); + + ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s)); + if (ret) + ret = -EFAULT; + +sys_time_pps_cmd_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params) +{ + int ret = 0; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!params) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getparams_exit; + } + + /* Return current parameters */ + ret = copy_to_user(params, &pps_source[source].params, + sizeof(struct pps_kparams)); + if (ret) + ret = -EFAULT; + +sys_time_pps_getparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Check the capabilities */ + if (!capable(CAP_SYS_TIME)) + return -EPERM; + + /* Sanity checks */ + if (!params) + return -EINVAL; + if ((params->mode & ~pps_source[source].info->mode) != 0) { + pps_dbg("unsupported capabilities"); + return -EINVAL; + } + if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + pps_dbg("capture mode unspecified"); + return -EINVAL; + } + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_setparams_exit; + } + + /* Save the new parameters */ + ret = copy_from_user(&pps_source[source].params, params, + sizeof(struct pps_kparams)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_setparams_exit; + } + + /* Restore the read only parameters */ + if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + /* section 3.3 of RFC 2783 interpreted */ + pps_dbg("time format unspecified"); + pps_source[source].params.mode |= PPS_TSFMT_TSPEC; + } + if (pps_source[source].info->mode & PPS_CANWAIT) + pps_source[source].params.mode |= PPS_CANWAIT; + pps_source[source].params.api_version = PPS_API_VERS; + +sys_time_pps_setparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getcap(int source, int __user *mode) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!mode) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getcap_exit; + } + + ret = put_user(pps_source[source].info->mode, mode); + +sys_time_pps_getcap_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout) +{ + unsigned long ticks; + struct pps_kinfo pi; + struct pps_ktime to; + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + if (!info) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_fetch_exit; + } + + pps_source[source].go = 0; + + /* Manage the timeout */ + if (timeout) { + ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime)); + if (ret) { + goto sys_time_pps_fetch_exit; + ret = -EFAULT; + } + pps_dbg("timeout %lld.%09d", to.sec, to.nsec); + ticks = to.sec * HZ; + ticks += to.nsec / (NSEC_PER_SEC / HZ); + + if (ticks != 0) { + ret = wait_event_interruptible_timeout( + pps_source[source].queue, + pps_source[source].go, ticks); + if (ret == 0) { + pps_dbg("timeout expired"); + ret = -ETIMEDOUT; + goto sys_time_pps_fetch_exit; + } + } + } else + ret = wait_event_interruptible(pps_source[source].queue, + pps_source[source].go); + + /* Check for pending signals */ + if (ret == -ERESTARTSYS) { + pps_dbg("pending signal caught"); + ret = -EINTR; + goto sys_time_pps_fetch_exit; + } + + /* Return the fetched timestamp */ + pi.assert_sequence = pps_source[source].assert_sequence; + pi.clear_sequence = pps_source[source].clear_sequence; + pi.assert_tu = pps_source[source].assert_tu; + pi.clear_tu = pps_source[source].clear_tu; + pi.current_mode = pps_source[source].current_mode; + ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo)); + if (ret) + ret = -EFAULT; + +sys_time_pps_fetch_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +/* + * Module staff + */ + +static void __exit pps_exit(void) +{ + pps_sysfs_unregister(); + + pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS); +} + +static int __init pps_init(void) +{ + int i, ret; + + /* Init pps_source info */ + dummy_info.echo = dummy_echo; + for (i = 0; i < PPS_MAX_SOURCES; i++) { + pps_source[i].info = &dummy_info; + init_waitqueue_head(&pps_source[i].queue); + } + + /* Register to sysfs */ + ret = pps_sysfs_register(); + if (ret < 0) { + pps_err("unable to register sysfs"); + return ret; + } + + pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS); + pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti " + "<giometti@linux.it>", PPS_VERSION); + + return 0; +} + +subsys_initcall(pps_init); +module_exit(pps_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..e52dd8e --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,217 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> + +#include <linux/pps.h> + +/* + * Private functions + */ + +static ssize_t pps_show_assert(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->assert_tu.sec, dev->assert_tu.nsec, + dev->assert_sequence); +} + +static ssize_t pps_show_clear(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->clear_tu.sec, dev->clear_tu.nsec, + dev->clear_sequence); +} + +static ssize_t pps_show_mode(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%4x\n", info->mode); +} + +static ssize_t pps_show_echo(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%d\n", !!info->echo); +} + +static ssize_t pps_show_name(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->name); +} + +static ssize_t pps_show_path(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->path); +} + +/* + * Files definitions + */ + +#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \ +{ \ + .attr = { \ + .name = __stringify(_name), \ + .mode = _mode, \ + .owner = THIS_MODULE, \ + }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute pps_class_device_attributes[] = { + DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL), + DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL), + DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL), + DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL), + DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL), + DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL), +}; + +/* + * Class definitions + */ + +static void pps_class_release(struct class_device *cdev) +{ + /* Nop??? */ +} + +static struct class pps_class = { + .name = "pps", + .release = pps_class_release, +}; + +/* + * Public functions + */ + +void pps_sysfs_remove_source_entry(struct pps_source_info_s *info) +{ + int i; + + /* Sanity checks */ + if (info == NULL) + return; + + /* Delete info files */ + if (info->mode&PPS_CAPTUREASSERT) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[0]); + + if (info->mode&PPS_CAPTURECLEAR) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[1]); + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + /* Deregister the pps class */ + class_device_unregister(&info->class_dev); +} + +int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id) +{ + char buf[32]; + int i, ret; + + /* Sanity checks */ + if (info == NULL || id >= PPS_MAX_SOURCES) + return -EINVAL; + + /* Create dir class device name */ + sprintf(buf, "%.02d", id); + + /* Setup the class struct */ + memset(&info->class_dev, 0, sizeof(struct class_device)); + info->class_dev.class = &pps_class; + strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN); + class_set_devdata(&info->class_dev, &pps_source[id]); + + /* Register the new class */ + ret = class_device_register(&info->class_dev); + if (unlikely(ret)) + goto error_class_device_register; + + /* Create info files */ + + /* Create file "assert" and "clear" according to source capability */ + if (info->mode & PPS_CAPTUREASSERT) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[0]); + i = 0; + if (unlikely(ret)) + goto error_class_device_create_file; + } + if (info->mode & PPS_CAPTURECLEAR) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[1]); + i = 1; + if (unlikely(ret)) + goto error_class_device_create_file; + } + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[i]); + if (unlikely(ret)) + goto error_class_device_create_file; + } + + return 0; + +error_class_device_create_file: + while (--i >= 0) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + class_device_unregister(&info->class_dev); + /* Here the release() method was already called */ + +error_class_device_register: + + return ret; +} + +void pps_sysfs_unregister(void) +{ + class_unregister(&pps_class); +} + +int pps_sysfs_register(void) +{ + return class_register(&pps_class); +} diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c index c84dab0..0c9a307 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 326020f..bd12165 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR, + -1 /* PPS ID is up to the system */); + if (ret < 0) { + pps_err("cannot register PPS source \"%s\"", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + pps_info("PPS source #%d \"%s\" added to the system ", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(&state->pps_info); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, state->pps_info.path); +} + +#else + +#define uart_register_pps_port(state, port) do { } while (0) +#define uart_unregister_pps_port(state, port) do { } while (0) + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h index e84ace1..36746dc 100644 --- a/include/asm-i386/unistd.h +++ b/include/asm-i386/unistd.h @@ -329,10 +329,15 @@ #define __NR_signalfd 321 #define __NR_timerfd 322 #define __NR_eventfd 323 +#define __NR_time_pps_cmd 324 +#define __NR_time_pps_getparams 325 +#define __NR_time_pps_setparams 326 +#define __NR_time_pps_getcap 327 +#define __NR_time_pps_fetch 328 #ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 329 #define __ARCH_WANT_IPC_PARSE_VERSION #define __ARCH_WANT_OLD_READDIR diff --git a/include/linux/Kbuild b/include/linux/Kbuild index f317c27..a10d20a 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -293,6 +293,7 @@ unifdef-y += pmu.h unifdef-y += poll.h unifdef-y += ppp_defs.h unifdef-y += ppp-comp.h +unifdef-y += pps.h unifdef-y += ptrace.h unifdef-y += qnx4_fs.h unifdef-y += quota.h diff --git a/include/linux/parport.h b/include/linux/parport.h index 9cdd694..f53d9f4 100644 --- a/include/linux/parport.h +++ b/include/linux/parport.h @@ -100,6 +100,7 @@ typedef enum { #include <linux/proc_fs.h> #include <linux/spinlock.h> #include <linux/wait.h> +#include <linux/pps.h> #include <asm/system.h> #include <asm/ptrace.h> #include <asm/semaphore.h> @@ -327,6 +328,11 @@ struct parport { struct list_head full_list; struct parport *slaves[3]; + +#ifdef CONFIG_PPS_CLIENT_LP + struct pps_source_info_s pps_info; + int pps_source; /* PPS source ID */ +#endif }; #define DEFAULT_SPIN_TIME 500 /* us */ @@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode); /* Lowlevel drivers _can_ call this support function to handle irqs. */ static __inline__ void parport_generic_irq(int irq, struct parport *port) { +#ifdef CONFIG_PPS_CLIENT_LP + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("parport_pc: PPS assert event at %lu on source #%d", + jiffies, port->pps_source); +#endif + parport_ieee1284_interrupt (irq, port); read_lock(&port->cad_lock); if (port->cad && port->cad->irq_func) diff --git a/include/linux/pps.h b/include/linux/pps.h new file mode 100644 index 0000000..f22c299 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,207 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +/* Implementation note: the logical states ``assert'' and ``clear'' + * are implemented in terms of the chip register, i.e. ``assert'' + * means the bit is set. */ + +/* + * 3.2 New data structures + */ + +#ifndef __KERNEL__ +#include <linux/types.h> +#include <sys/time.h> +#else +#include <linux/time.h> +#endif + +#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */ +#define PPS_API_VERS PPS_API_VERS_2 +#define LINUXPSS_API 1 /* mark LinuxPPS API */ + +#define PPS_MAX_NAME_LEN 32 + +struct pps_ktime { + __u64 sec; + __u32 nsec; +}; + +struct pps_kinfo { + __u32 assert_sequence; /* seq. num. of assert event */ + __u32 clear_sequence; /* seq. num. of clear event */ + struct pps_ktime assert_tu; /* time of assert event */ + struct pps_ktime clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_kparams { + int api_version; /* API version # */ + int mode; /* mode bits */ + struct pps_ktime assert_off_tu; /* offset compensation for assert */ + struct pps_ktime clear_off_tu; /* offset compensation for clear */ +}; + +/* + * 3.3 Mode bit definitions + */ + +/* Device/implementation parameters */ +#define PPS_CAPTUREASSERT 0x01 /* capture assert events */ +#define PPS_CAPTURECLEAR 0x02 /* capture clear events */ +#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */ + +#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */ +#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */ + +#define PPS_CANWAIT 0x100 /* can we wait for an event? */ +#define PPS_CANPOLL 0x200 /* bit reserved for future use */ + +/* Kernel actions */ +#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */ +#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */ + +/* Timestamp formats */ +#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */ +#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */ + +/* + * 3.4.4 New functions: disciplining the kernel timebase + */ + +/* Kernel consumers */ +#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */ +#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to + use a phase-locked loop */ +#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to + use a frequency-locked loop */ +/* + * Here begins the implementation-specific part! + */ + +#include <linux/ioctl.h> + +struct pps_source_data_s { + int source; + char name[PPS_MAX_NAME_LEN]; + char path[PPS_MAX_NAME_LEN]; +}; + +#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *) +#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *) + +#ifdef __KERNEL__ + +#include <linux/device.h> + +/* + * Misc macros + */ + +#define PPS_VERSION "4.0.0-rc4" + +#ifdef CONFIG_PPS_DEBUG +#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#else +#define pps_dbg(format, arg...) do {} while (0) +#endif + +#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) + +/* + * Global defines + */ + +#define PPS_MAX_SOURCES 16 + +/* The specific PPS source info */ +struct pps_source_info_s { + char name[PPS_MAX_NAME_LEN]; /* simbolic name */ + char path[PPS_MAX_NAME_LEN]; /* path of connected device */ + int mode; /* PPS's allowed mode */ + + void (*echo)(int source, int event, void *data); /* PPS echo function */ + + /* sysfs section */ + struct class_device class_dev; +}; + +/* The main struct */ +struct pps_s { + struct pps_source_info_s *info; /* PSS source info */ + + struct pps_kparams params; /* PPS's current params */ + + volatile __u32 assert_sequence; /* PPS' assert event seq # */ + volatile __u32 clear_sequence; /* PPS' clear event seq # */ + volatile struct pps_ktime assert_tu; + volatile struct pps_ktime clear_tu; + int current_mode; /* PPS mode at event time */ + + int go; /* PPS event is arrived? */ + wait_queue_head_t queue; /* PPS event queue */ +}; + +/* + * Global variables + */ + +extern struct pps_s pps_source[PPS_MAX_SOURCES]; +extern struct mutex pps_mutex; +extern struct pps_source_info_s dummy_info; + +/* + * Global functions + */ + +static inline int pps_is_allocated(int source) +{ + return pps_source[source].info != &dummy_info; +} + +#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev) + +/* + * Exported functions + */ + +extern int pps_register_source(struct pps_source_info_s *info, + int default_params, int try_id); +extern void pps_unregister_source(struct pps_source_info_s *info); +extern void pps_event(int source, int event, void *data); + +extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info, + int id); +extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info); +extern int pps_sysfs_register(void); +extern void pps_sysfs_unregister(void); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 7f2c99d..654ad19 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -153,6 +153,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -232,6 +233,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -276,7 +280,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -308,6 +313,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info_s pps_info; +#endif + struct mutex mutex; }; @@ -472,13 +481,26 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; +#ifdef CONFIG_PPS_CLIENT_UART + struct tty_driver *drv = port->info->tty->driver; -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("%s%d: PPS assert event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + pps_dbg("%s%d: PPS clear event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 83d0ec1..bfc8899 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -65,6 +65,7 @@ struct getcpu_cache; #include <asm/signal.h> #include <linux/quota.h> #include <linux/key.h> +#include <linux/pps.h> asmlinkage long sys_time(time_t __user *tloc); asmlinkage long sys_stime(time_t __user *tptr); @@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags, const struct itimerspec __user *utmr); asmlinkage long sys_eventfd(unsigned int count); +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg); +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params); +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params); +asmlinkage long sys_time_pps_getcap(int source, int __user *mode); +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout); + int kernel_execve(const char *filename, char *const argv[], char *const envp[]); #endif diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 7e11e2c..e0fccc2 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -148,3 +148,10 @@ cond_syscall(sys_timerfd); cond_syscall(compat_sys_signalfd); cond_syscall(compat_sys_timerfd); cond_syscall(sys_eventfd); + +/* PPS dependent */ +cond_syscall(sys_time_pps_find); +cond_syscall(sys_time_pps_getparams); +cond_syscall(sys_time_pps_setparams); +cond_syscall(sys_time_pps_getcap); +cond_syscall(sys_time_pps_fetch); ^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 8:00 ` Rodolfo Giometti @ 2007-07-24 13:49 ` David Woodhouse 2007-07-24 14:20 ` Rodolfo Giometti 2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti 0 siblings, 2 replies; 43+ messages in thread From: David Woodhouse @ 2007-07-24 13:49 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton On Tue, 2007-07-24 at 10:00 +0200, Rodolfo Giometti wrote: > On Mon, Jul 23, 2007 at 02:35:16PM +0100, David Woodhouse wrote: > > > > s/Documentaion/Documentation/ in the last line of Documentation/pps/pps.txt > > Fixed. Also 's/unknow /unknown /' (2 instances) > > Please feed it to scripts/checkpatch.pl -- you can ignore all the > > warnings about lines greater than 80 characters, and the complete crap > > about "declaring multiple variables together should be avoided", but > > Done. Most fixed. Looks better. > > some of what it points out is valid. Including the one about 'volatile' > > -- your explanation lacked credibility. If you really need 'volatile' > > then put it at the places you actually need it; not the declaration of > > the structure. > > Can you please explain better where should I put the 'volatile' > attribute? :-o Am I right in thinking that the only place it matters is within pps_event()? In that case, at the very least you should probably remove the 'volatile' from the definition of the structure, and _cast_ to volatile where you want it treated that way. But I don't see why you can't protect it with a spinlock. As long as you acquire that spinlock _after_ your call to getnstimeofday() what's the problem? > > ... > This should be not needed due new 'struct pps_ktime'. > > ... > These typedefs are into timepps.h which is an userland file (located > into Documentation/pps/) and are requested by the RFC. Sorry, yes. I shouldn't have been looking at that as if it was kernel code. I think you still haven't quite got the 32-bit vs. 64-bit compatibility right. Remember that on i386, the alignment of a uint64_t is only 4 bytes, while on most other architectures it's 8 bytes. On i386, there will be no padding between the two consecutive 'struct pps_ktime' members of struct pps_kinfo and struct pps_kparams. But on most platforms there will be padding to ensure correct alignment. The simple fix is probably to make the 'nsec' member a 64-bit integer too. Then it'll be the same for i386 and x86_64 and you won't need a compatibility syscall routine. In order for your handling of 'pps_source[source].info' to be safe with respect to pps_unregister_source(), you have to guarantee that pps_event() has finished -- and can't be in progress on another CPU -- by the time your client's call to pps_unregister_source() completes. At first glance I think your existing clients have that right (you have del_timer_sync() before pps_unregister_source() in ktimer.c, for example). But you should make sure it's clearly documented for new clients. Shouldn't your PPS_CLIENT_LP and PPS_CLIENT_UART options depend on PARPORT and SERIAL_CORE respectively? -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 13:49 ` David Woodhouse @ 2007-07-24 14:20 ` Rodolfo Giometti 2007-07-24 14:46 ` David Woodhouse 2007-07-24 14:52 ` David Woodhouse 2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti 1 sibling, 2 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-24 14:20 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote: > Also 's/unknow /unknown /' (2 instances) ?? I didn't find them: $ grep 'unknow ' Documentation/pps/pps.txt > Am I right in thinking that the only place it matters is within > pps_event()? In that case, at the very least you should probably remove > the 'volatile' from the definition of the structure, and _cast_ to > volatile where you want it treated that way. Ok, I see. > But I don't see why you can't protect it with a spinlock. As long as you > acquire that spinlock _after_ your call to getnstimeofday() what's the > problem? The problem is that we can have several PPS sources into a system and all these sources will arise their IRQ line (quasi)simultaneously and I don't wish a CPU may delay one of these IRQ handler due a spinlock into the pps_event(). That's why I'm trying to avoid any lock into pps_event(). > I think you still haven't quite got the 32-bit vs. 64-bit compatibility > right. Remember that on i386, the alignment of a uint64_t is only 4 > bytes, while on most other architectures it's 8 bytes. On i386, there > will be no padding between the two consecutive 'struct pps_ktime' > members of struct pps_kinfo and struct pps_kparams. But on most > platforms there will be padding to ensure correct alignment. > > The simple fix is probably to make the 'nsec' member a 64-bit integer > too. Then it'll be the same for i386 and x86_64 and you won't need a > compatibility syscall routine. Ok. I'll add your comment too. > In order for your handling of 'pps_source[source].info' to be safe with > respect to pps_unregister_source(), you have to guarantee that > pps_event() has finished -- and can't be in progress on another CPU -- > by the time your client's call to pps_unregister_source() completes. At > first glance I think your existing clients have that right (you have > del_timer_sync() before pps_unregister_source() in ktimer.c, for > example). But you should make sure it's clearly documented for new > clients. This can be done only with locks, but it's not necessary since even if a pps_unregister_source() runs while pps_event() executes on another CPU the latter will write always on a valid area (even if it could be a dummy one) and the data are not corrupted (note also that the data will be, in any case, discarted since we are executing a pps_unregister_source()). > Shouldn't your PPS_CLIENT_LP and PPS_CLIENT_UART options depend on > PARPORT and SERIAL_CORE respectively? No. These options can be enabled but if no serial/parallel driver is loaded no PPS source is registered. Thanks, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:20 ` Rodolfo Giometti @ 2007-07-24 14:46 ` David Woodhouse 2007-07-24 14:52 ` David Woodhouse 1 sibling, 0 replies; 43+ messages in thread From: David Woodhouse @ 2007-07-24 14:46 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton On Tue, 2007-07-24 at 16:20 +0200, Rodolfo Giometti wrote: > The problem is that we can have several PPS sources into a system and > all these sources will arise their IRQ line (quasi)simultaneously and > I don't wish a CPU may delay one of these IRQ handler due a spinlock > into the pps_event(). > > That's why I'm trying to avoid any lock into pps_event(). The spinlock really wouldn't be held for long. It really shouldn't be a problem, and it shouldn't hold up your timings at all. And presumably you'd have a _different_ spinlock for each source, so they wouldn't stomp on each other at all. -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:20 ` Rodolfo Giometti 2007-07-24 14:46 ` David Woodhouse @ 2007-07-24 14:52 ` David Woodhouse 2007-07-24 16:01 ` Rodolfo Giometti 2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti 1 sibling, 2 replies; 43+ messages in thread From: David Woodhouse @ 2007-07-24 14:52 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton On Tue, 2007-07-24 at 16:20 +0200, Rodolfo Giometti wrote: > On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote: > > > Also 's/unknow /unknown /' (2 instances) > > ?? I didn't find them: > > $ grep 'unknow ' Documentation/pps/pps.txt Elsewhere in the patch. > > In order for your handling of 'pps_source[source].info' to be safe with > > respect to pps_unregister_source(), you have to guarantee that > > pps_event() has finished -- and can't be in progress on another CPU -- > > by the time your client's call to pps_unregister_source() completes. At > > first glance I think your existing clients have that right (you have > > del_timer_sync() before pps_unregister_source() in ktimer.c, for > > example). But you should make sure it's clearly documented for new > > clients. > > This can be done only with locks, but it's not necessary since even if > a pps_unregister_source() runs while pps_event() executes on another > CPU the latter will write always on a valid area (even if it could be > a dummy one) and the data are not corrupted (note also that the data > will be, in any case, discarted since we are executing a > pps_unregister_source()). Read Documentation/memory-barriers.txt There is a tiny but possibly non-zero chance that one CPU could be in pps_event() and might not yet have 'seen' the change to the .info field. Releasing the pps_mutex provides a write-barrier on the CPU which runs pps_unregister_source(), but there's no corresponding read-barrier on the CPU running pps_event(). You have to be careful about when pps_event() is run. It _MUST_ not touch the old info structure after pps_unregister_source() has completed. At the moment, I think it's OK because you won't be calling pps_event() at the wrong times. But you do need to make sure that requirement is documented. And I think you can remove the whole dummy_info thing because it's not necessary. -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:52 ` David Woodhouse @ 2007-07-24 16:01 ` Rodolfo Giometti 2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti 1 sibling, 0 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-24 16:01 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton [-- Attachment #1: Type: text/plain, Size: 1286 bytes --] On Tue, Jul 24, 2007 at 03:52:49PM +0100, David Woodhouse wrote: > > Elsewhere in the patch. Got, thanks. > Read Documentation/memory-barriers.txt > > There is a tiny but possibly non-zero chance that one CPU could be in > pps_event() and might not yet have 'seen' the change to the .info field. > Releasing the pps_mutex provides a write-barrier on the CPU which runs > pps_unregister_source(), but there's no corresponding read-barrier on > the CPU running pps_event(). You have to be careful about when > pps_event() is run. It _MUST_ not touch the old info structure after > pps_unregister_source() has completed. > > At the moment, I think it's OK because you won't be calling pps_event() > at the wrong times. But you do need to make sure that requirement is > documented. And I think you can remove the whole dummy_info thing > because it's not necessary. What about this new solution involving tasklets? The pps_event() now just records data and then a tasklet do the data management job. :) Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 [-- Attachment #2: proposed_patch --] [-- Type: text/plain, Size: 68780 bytes --] diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..a2660a2 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest ppsctl + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section ---------------------------------------------------------- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section ------------------------------------------------------------ + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt new file mode 100644 index 0000000..511fa36 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,211 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you change the original RFC 2783: + + pps_handle_t type is an opaque __scalar type__ used to represent a + PPS source within the API + +into a modified: + + pps_handle_t type is an opaque __variable__ used to represent a PPS + source within the API and programs should not access it directly to + it due to its opacity. + +This change seems to be neglibile because even the original RFC 2783 +does not encourage programs to check (read: use) the pps_handle_t +variable before calling the time_pps_*() functions, since each +function should do this job internally. + +If I intentionally separate the concept of "file descriptor" from the +concept of the "PPS source" I'm obliged to provide a solution to find +and register a PPS-source without using a file descriptor: it's done +by the functions time_pps_findsource() and time_pps_findpath() now. + +According to this current NTPD drivers' code should be modified as +follows: + ++#ifdef PPS_HAVE_FINDPATH ++ /* Get the PPS source's real name */ ++ fd = readlink(link, path, STRING_LEN-1); ++ if (fd <= 0) ++ strncpy(path, link, STRING_LEN); ++ else ++ path[fd] = '\0'; ++ ++ /* Try to find the source */ ++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); ++ if (fd < 0) { ++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" " ++ "in the system", path); ++ return 1; ++ } ++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"", ++ fd, path, id); ++#endif /* PPS_HAVE_FINDPATH */ ++ ++ + if (time_pps_create(fd, &pps_handle) < 0) { +- pps_handle = 0; + msyslog(LOG_ERR, "refclock: time_pps_create failed: %m"); + } + + +Coding example +-------------- + +To register a PPS source into the kernel you should define a struct +pps_source_info_s as follow: + + static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, + }; + +and then calling the function pps_register_source() in your +intialization routine as follow: + + source = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + +The pps_register_source() prototype is: + + int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) + +where "info" is a pointer to a structure that describes a particular +PPS source, "default_params" tells the system what the initial default +parameters for the device should be (is obvious that these parameters +must be a subset of ones defined into the struct +pps_source_info_s which describe the capabilities of the driver) +and "try_id" can be used to force a particular ID for your device into +the system (just use -1 if you wish the system chooses one for you). + +Once you have registered a new PPS source into the system you can +signal an assert event (for example in the interrupt handler routine) +just using: + + pps_event(source, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for an example code. + + +SYSFS support +------------- + +The SYSFS support is enabled by default if the SYSFS filesystem is +enabled in the kernel and it provides a new class: + + $ ls /sys/class/pps/ + 00/ 01/ 02/ + +Every directory is the ID of a PPS sources defined into the system and +inside you find several files: + + $ ls /sys/class/pps/00/ + assert clear echo mode name path subsystem@ uevent + +Inside each "assert" and "clear" file you can find the timestamp and a +sequence number: + + $ cat /sys/class/pps/00/assert + 1170026870.983207967#8 + +Where before the "#" is the timestamp in seconds and after it is the +sequence number. Other files are: + +* echo: reports if the PPS source has an echo function or not; + +* mode: reports available PPS functioning modes; + +* name: reports the PPS source's name; + +* path: reports the PPS source's device path, that is the device the + PPS source is connected to (if it exists). + + +Testing the PPS support +----------------------- + +In order to test the PPS support even without specific hardware you can use +the ktimer driver (see the client subsection in the PPS configuration menu) +and the userland tools provided into Documentaion/pps/ directory. + +Once you have enabled the compilation of ktimer just modprobe it (if +not statically compiled): + + # modprobe ktimer + +and the run ppstest as follow: + + $ ./ppstest + found PPS source #0 "ktimer" on "" + ok, found 1 source(s), now start fetching data... + source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0 + source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0 + +Please, note that to compile userland programs you need the file timepps.h +(see Documentation/pps/). diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c new file mode 100644 index 0000000..17afcbd --- /dev/null +++ b/Documentation/pps/ppsctl.c @@ -0,0 +1,61 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <string.h> +#include <linux/serial.h> + +void usage(char *name) +{ + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name); + + exit(EXIT_FAILURE); +} + +int main(int argc, char *argv[]) +{ + int fd, ret; + struct serial_struct ss; + + if (argc < 2) + usage(argv[0]); + + fd = open(argv[1], O_RDWR); + if (fd < 0) { + perror("open"); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCGSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCGSERIAL)"); + exit(EXIT_FAILURE); + } + + if (argc < 3) { /* just read PPS status */ + printf("PPS is %sabled\n", + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis"); + exit(EXIT_SUCCESS); + } + + if (argv[2][0] == 'e' || argv[2][0] == '1') + ss.flags |= ASYNC_HARDPPS_CD; + else if (argv[2][0] == 'd' || argv[2][0] == '0') + ss.flags &= ~ASYNC_HARDPPS_CD; + else { + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCSSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCSSERIAL)"); + exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c new file mode 100644 index 0000000..bfd1064 --- /dev/null +++ b/Documentation/pps/ppstest.c @@ -0,0 +1,201 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <timepps.h> + +#define STRING_LEN PPS_MAX_NAME_LEN + +int find_source(int try_link, char *link, pps_handle_t *handle, + int *avail_mode) +{ + int num = -1; + char id[STRING_LEN] = "", /* no ID string by default */ + path[STRING_LEN]; + pps_params_t params; + int ret; + + if (try_link) { + printf("trying PPS source \"%s\"\n", link); +#ifdef PPS_HAVE_FINDPATH + /* Get the PPS source's real name */ + time_pps_readlink(link, STRING_LEN, path, STRING_LEN); + + /* Try to find the source by using the supplied "path" name */ + ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); + if (ret < 0) + goto exit; + num = ret; +#else +#warning "cannot use time_pps_findpath()" + ret = -1; +#endif /* PPS_HAVE_FINDPATH */ + } +#ifdef PPS_HAVE_FINDSOURCE + /* Try to find the source (by using "index = -1" we ask just + * for a generic source) */ + ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN); +#else +#warning "cannot use time_pps_findsource()" + ret = -1; +#endif /* PPS_HAVE_FINDSOURCE */ + if (ret < 0) { +exit: + fprintf(stderr, "no available PPS source in the system\n"); + return -1; + } + num = ret; + printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path); + + /* If "path" is not NULL we should *at least* open the pointed + * device in order to enable the interrupts generation. + * Note that this can be NOT enough anyway, infact you may need sending + * additional commands to your GPS antenna before it starts sending + * the PPS signal. */ + if (strlen(path)) { + ret = open(path, O_RDWR); + if (ret < 0) { + fprintf(stderr, "cannot open \"%s\" (%m)\n", path); + return -1; + } + } + + /* Open the PPS source */ + ret = time_pps_create(num, handle); + if (ret < 0) { + fprintf(stderr, "cannot create a PPS source (%m)\n"); + return -1; + } + + /* Find out what features are supported */ + ret = time_pps_getcap(*handle, avail_mode); + if (ret < 0) { + fprintf(stderr, "cannot get capabilities (%m)\n"); + return -1; + } + if ((*avail_mode & PPS_CAPTUREASSERT) == 0) { + fprintf(stderr, "cannot CAPTUREASSERT\n"); + return -1; + } + if ((*avail_mode & PPS_OFFSETASSERT) == 0) { + fprintf(stderr, "cannot OFFSETASSERT\n"); + return -1; + } + + /* Capture assert timestamps, and compensate for a 675 nsec + * propagation delay */ + ret = time_pps_getparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot get parameters (%m)\n"); + return -1; + } + params.assert_offset.tv_sec = 0; + params.assert_offset.tv_nsec = 675; + params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT; + ret = time_pps_setparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot set parameters (%m)\n"); + return -1; + } + + return 0; +} + +int fetch_source(int i, pps_handle_t *handle, int *avail_mode) +{ + struct timespec timeout; + pps_info_t infobuf; + int ret; + + /* create a zero-valued timeout */ + timeout.tv_sec = 3; + timeout.tv_nsec = 0; + +retry: + if (*avail_mode & PPS_CANWAIT) { + /* waits for the next event */ + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } else { + sleep(1); + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } + if (ret < 0) { + if (ret == -EINTR) { + fprintf(stderr, "time_pps_fetch() got a signal!\n"); + goto retry; + } + + fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret); + return -1; + } + + printf("source %d - " + "assert %ld.%09ld, sequence: %ld - " + "clear %ld.%09ld, sequence: %ld\n", + i, + infobuf.assert_timestamp.tv_sec, + infobuf.assert_timestamp.tv_nsec, + infobuf.assert_sequence, + infobuf.clear_timestamp.tv_sec, + infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int num, try_link = 0; /* by default use findsource */ + char link[STRING_LEN] = "/dev/gps0"; /* just a default device */ + pps_handle_t handle[4]; + int avail_mode[4]; + int i = 0, ret; + + if (argc == 1) { + ret = find_source(try_link, link, &handle[0], &avail_mode[0]); + if (ret < 0) + exit(EXIT_FAILURE); + + num = 1; + } else { + for (i = 1; i < argc && i <= 4; i++) { + ret = sscanf(argv[i], "%d", &num); + if (ret < 1) { + try_link = ~0; + strncpy(link, argv[i], STRING_LEN); + } + + ret = + find_source(try_link, link, &handle[i - 1], + &avail_mode[i - 1]); + if (ret < 0) + exit(EXIT_FAILURE); + } + + num = i - 1; + } + + printf("ok, found %d source(s), now start fetching data...\n", num); + + /* loop, printing the most recent timestamp every second or so */ + while (1) { + for (i = 0; i < num; i++) { + ret = fetch_source(i, &handle[i], &avail_mode[i]); + if (ret < 0 && errno != ETIMEDOUT) + exit(EXIT_FAILURE); + } + } + + for (; i >= 0; i--) + time_pps_destroy(handle[i]); + + return 0; +} diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h new file mode 100644 index 0000000..dee1782 --- /dev/null +++ b/Documentation/pps/timepps.h @@ -0,0 +1,234 @@ +/* + * timepps.h -- PPS API main header + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +/* + * New data structures + */ + +struct ntp_fp { + unsigned int integral; + unsigned int fractional; +}; + +union pps_timeu { + struct timespec tspec; + struct ntp_fp ntpfp; + unsigned long longpad[3]; +}; + +struct pps_info { + unsigned long assert_sequence; /* seq. num. of assert event */ + unsigned long clear_sequence; /* seq. num. of clear event */ + union pps_timeu assert_tu; /* time of assert event */ + union pps_timeu clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_params { + int api_version; /* API version # */ + int mode; /* mode bits */ + union pps_timeu assert_off_tu; /* offset compensation for assert */ + union pps_timeu clear_off_tu; /* offset compensation for clear */ +}; + +typedef int pps_handle_t; /* represents a PPS source */ +typedef unsigned long pps_seq_t; /* sequence number */ +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */ +typedef struct pps_info pps_info_t; +typedef struct pps_params pps_params_t; + +#define assert_timestamp assert_tu.tspec +#define clear_timestamp clear_tu.tspec + +#define assert_timestamp_ntpfp assert_tu.ntpfp +#define clear_timestamp_ntpfp clear_tu.ntpfp + +#define assert_offset assert_off_tu.tspec +#define clear_offset clear_off_tu.tspec + +#define assert_offset_ntpfp assert_off_tu.ntpfp +#define clear_offset_ntpfp clear_off_tu.ntpfp + +/* + * The PPS API + */ + +#define PPS_HAVE_FINDSOURCE 1 +#define pps_min(a, b) (a) < (b) ? a : b +int time_pps_findsource(int index, char *path, int pathlen, char *idstring, + int idlen) +{ + struct pps_source_data_s data; + int ret; + + data.source = index; + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +/* Defined iff PPS_HAVE_FINDPATH is defined */ +void time_pps_readlink(char *link, int linklen, char *path, int pathlen) +{ + int i; + + i = readlink(link, path, pathlen - 1); + if (i <= 0) { + /* "link" is not a valid symbolic so we directly use it */ + strncpy(path, link, linklen <= pathlen ? linklen : pathlen); + return; + } + + /* Return the file name where "link" points to */ + path[i] = '\0'; +} + +#define PPS_HAVE_FINDPATH 1 +int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen) +{ + struct pps_source_data_s data; + int ret; + + strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +int time_pps_create(int source, pps_handle_t *handle) +{ + if (!handle) { + errno = EINVAL; + return -1; + } + + /* In LinuxPPS there are no differences between a PPS source and + * a PPS handle so we return the same value. + */ + *handle = source; + + return 0; +} + +int time_pps_destroy(pps_handle_t handle) +{ + /* Nothing to destroy here */ + + return 0; +} + +int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams) +{ + int ret; + struct pps_kparams __ppsparams; + + ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams); + + ppsparams->api_version = __ppsparams.api_version; + ppsparams->mode = __ppsparams.mode; + ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec; + ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec; + ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec; + ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec; + + return ret; +} + +int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams) +{ + struct pps_kparams __ppsparams; + + __ppsparams.api_version = ppsparams->api_version; + __ppsparams.mode = ppsparams->mode; + __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec; + __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec; + __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec; + __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec; + + return syscall(__NR_time_pps_getparams, handle, &__ppsparams); +} + +/* Get capabilities for handle */ +int time_pps_getcap(pps_handle_t handle, int *mode) +{ + return syscall(__NR_time_pps_getcap, handle, mode); +} + +int time_pps_fetch(pps_handle_t handle, const int tsformat, + pps_info_t *ppsinfobuf, const struct timespec *timeout) +{ + struct pps_kinfo __ppsinfobuf; + struct pps_ktime __timeout; + int ret; + + /* Sanity checks */ + if (tsformat != PPS_TSFMT_TSPEC) { + errno = EINVAL; + return -1; + } + + if (timeout) { + __timeout.sec = timeout->tv_sec; + __timeout.nsec = timeout->tv_nsec; + } + + ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf, + timeout ? &__timeout : NULL); + + ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence; + ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence; + ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec; + ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec; + ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec; + ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec; + ppsinfobuf->current_mode = __ppsinfobuf.current_mode; + + return ret; +} + +int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer, + const int edge, const int tsformat) +{ + /* LinuxPPS doesn't implement kernel consumer feature */ + errno = EOPNOTSUPP; + return -1; +} + +#endif /* _SYS_TIMEPPS_H_ */ diff --git a/MAINTAINERS b/MAINTAINERS index df40a4e..17e9a02 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2903,6 +2903,13 @@ P: Michal Ostrowski M: mostrows@speakeasy.net S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S index bf6adce..f1bf4ff 100644 --- a/arch/i386/kernel/syscall_table.S +++ b/arch/i386/kernel/syscall_table.S @@ -323,3 +323,8 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_time_pps_cmd + .long sys_time_pps_getparams /* 325 */ + .long sys_time_pps_setparams + .long sys_time_pps_getcap + .long sys_time_pps_fetch diff --git a/drivers/Kconfig b/drivers/Kconfig index 050323f..bb54cab 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig" source "drivers/spi/Kconfig" +source "drivers/pps/Kconfig" + source "drivers/w1/Kconfig" source "drivers/hwmon/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index adad2f3..985d495 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_I2O) += message/ obj-$(CONFIG_RTC_LIB) += rtc/ obj-y += i2c/ +obj-$(CONFIG_PPS) += pps/ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/ obj-$(CONFIG_PHONE) += telephony/ diff --git a/drivers/char/lp.c b/drivers/char/lp.c index 62051f8..403753f 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -746,6 +746,27 @@ static struct console lpcons = { #endif /* console on line printer */ +/* Support for PPS signal on the line printer */ + +#ifdef CONFIG_PPS_CLIENT_LP + +static void lp_pps_echo(int source, int event, void *data) +{ + struct parport *port = data; + unsigned char status = parport_read_status(port); + + /* echo event via SEL bit */ + parport_write_control(port, + parport_read_control(port) | PARPORT_CONTROL_SELECT); + + /* signal no event */ + if ((status & PARPORT_STATUS_ACK) != 0) + parport_write_control(port, + parport_read_control(port) & ~PARPORT_CONTROL_SELECT); +} + +#endif + /* --- initialisation code ------------------------------------- */ static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC }; @@ -817,6 +838,35 @@ static int lp_register(int nr, struct parport *port) } #endif +#ifdef CONFIG_PPS_CLIENT_LP + snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr); + + /* No PPS support if lp port has no IRQ line */ + if (port->irq != PARPORT_IRQ_NONE) { + strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN); + + port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + port->pps_info.echo = lp_pps_echo; + + port->pps_source = pps_register_source(&(port->pps_info), + PPS_CAPTUREASSERT | PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (port->pps_source < 0) + pps_err("cannot register PPS source \"%s\"", + port->pps_info.path); + else + pps_info("PPS source #%d \"%s\" added to the system", + port->pps_source, port->pps_info.path); + } else { + port->pps_source = -1; + pps_err("PPS support disabled due port \"%s\" is in polling mode", + port->pps_info.path); + } +#endif + return 0; } @@ -860,6 +910,14 @@ static void lp_detach (struct parport *port) console_registered = NULL; } #endif /* CONFIG_LP_CONSOLE */ + +#ifdef CONFIG_PPS_CLIENT_LP + if (port->pps_source >= 0) { + pps_unregister_source(&(port->pps_info)); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, port->pps_info.path); + } +#endif } static struct parport_driver lp_driver = { diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig new file mode 100644 index 0000000..a00b59a --- /dev/null +++ b/drivers/pps/Kconfig @@ -0,0 +1,31 @@ +# +# PPS support configuration +# + +menu "PPS support" + +config PPS + bool "PPS support" + depends on EXPERIMENTAL + ---help--- + PPS (Pulse Per Second) is a special pulse provided by some GPS + antennae. Userland can use it to get an high time reference. + + Some antennae's PPS signals are connected with the CD (Carrier + Detect) pin of the serial line they use to communicate with the + host. In this case use the SERIAL_LINE client support. + + Some antennae's PPS signals are connected with some special host + inputs so you have to enable the corresponding client support. + +config PPS_DEBUG + bool "PPS debugging messages" + depends on PPS + help + Say Y here if you want the PPS support to produce a bunch of debug + messages to the system log. Select this if you are having a + problem with PPS support and want to see more of what is going on. + +source drivers/pps/clients/Kconfig + +endmenu diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile new file mode 100644 index 0000000..76101cd --- /dev/null +++ b/drivers/pps/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the PPS core. +# + +pps_core-objs += pps.o kapi.o sysfs.o +obj-$(CONFIG_PPS) += pps_core.o +obj-y += clients/ diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig new file mode 100644 index 0000000..58a1e55 --- /dev/null +++ b/drivers/pps/clients/Kconfig @@ -0,0 +1,30 @@ +# +# PPS clients configuration +# + +if PPS + +comment "PPS clients support" + +config PPS_CLIENT_KTIMER + tristate "Kernel timer client (Testing client, use for debug)" + help + If you say yes here you get support for a PPS debugging client + which uses a kernel timer to generate the PPS signal. + + This driver can also be built as a module. If so, the module + will be called ktimer.ko. + +config PPS_CLIENT_UART + bool "UART serial support" + help + If you say yes here you get support for a PPS source connected + with the CD (Carrier Detect) pin of your serial port. + +config PPS_CLIENT_LP + bool "Parallel printer support" + help + If you say yes here you get support for a PPS source connected + with the interrupt pin of your parallel port. + +endif diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile new file mode 100644 index 0000000..10d1dfa --- /dev/null +++ b/drivers/pps/clients/Makefile @@ -0,0 +1,6 @@ +# +# Makefile for PPS clients. +# + +obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o + diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c new file mode 100644 index 0000000..efd6eba --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pps_info("PPS event at %lu", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pps_info("echo %s %s for source %d", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, +}; + +/* + * Module staff + */ + +static void __exit pps_ktimer_exit(void) +{ + del_timer_sync(&ktimer); + pps_unregister_source(&pps_ktimer_info); + + pps_info("ktimer PPS source unregistered"); +} + +static int __init pps_ktimer_init(void) +{ + int ret; + + ret = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (ret < 0) { + pps_err("cannot register ktimer source"); + return ret; + } + source = ret; + + setup_timer(&ktimer, pps_ktimer_event, 0); + mod_timer(&ktimer, jiffies + HZ); + + pps_info("ktimer PPS source registered at %d", source); + + return 0; +} + +module_init(pps_ktimer_init); +module_exit(pps_ktimer_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c new file mode 100644 index 0000000..3047462 --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,242 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/pps.h> + +/* + * Local functions + */ + +void dummy_echo(int source, int event, void *data) +{ + /* Nop */ +} + +static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset) +{ + ts->nsec += offset->nsec; + if (ts->nsec >= NSEC_PER_SEC) { + ts->nsec -= NSEC_PER_SEC; + ts->sec++; + } else if (ts->nsec < 0) { + ts->nsec += NSEC_PER_SEC; + ts->sec--; + } + ts->sec += offset->sec; +} + +static void pps_tasklet(unsigned long data) +{ + int source = data; + struct pps_ktime ts; + + struct timespec __ts; + int event; + + /* If we are here then the source is allocated so no need to use + * pps_is_allocated(). + */ + + /* Get the last event data saved by the IRQ handler */ + __ts = pps_source[source].ts; + event = pps_source[source].event; + + /* Translate the saved timestamp into PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { + pps_err("unknow event (%x) for source %d", event, source); + return; + } + + /* Check the event */ + pps_source[source].current_mode = pps_source[source].params.mode; + if (event & PPS_CAPTUREASSERT) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETASSERT) + pps_add_offset(&ts, + &pps_source[source].params.assert_off_tu); + + /* Save the time stamp */ + pps_source[source].assert_tu = ts; + pps_source[source].assert_sequence++; + pps_dbg("capture assert seq #%u for source %d", + pps_source[source].assert_sequence, source); + } + if (event & PPS_CAPTURECLEAR) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETCLEAR) + pps_add_offset(&ts, + &pps_source[source].params.clear_off_tu); + + /* Save the time stamp */ + pps_source[source].clear_tu = ts; + pps_source[source].clear_sequence++; + pps_dbg("capture clear seq #%u for source %d", + pps_source[source].clear_sequence, source); + } + + pps_source[source].go = ~0; + wake_up_interruptible(&pps_source[source].queue); +} + +/* + * Exported functions + */ + +int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) +{ + int i = -1, err = 0, ret; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + if (try_id >= 0) { + if (pps_is_allocated(try_id)) { + pps_err("source id %d busy", try_id); + err = -EBUSY; + goto pps_register_source_exit; + } + i = try_id; + } else { + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (!pps_is_allocated(i)) + break; + if (i >= PPS_MAX_SOURCES) { + pps_err("no free source ids"); + err = -ENOMEM; + goto pps_register_source_exit; + } + } + tasklet_disable(&pps_source[i].tasklet); + tasklet_kill(&pps_source[i].tasklet); + + /* Sanity checks */ + if ((info->mode & default_params) != default_params) { + pps_err("unsupported default parameters"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 && + info->echo == NULL) { + pps_err("echo function is not defined"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + pps_err("unspecified time format"); + err = -EINVAL; + goto pps_register_source_exit; + } + + /* Allocate the PPS source. */ + memset(&pps_source[i], 0, sizeof(struct pps_s)); + pps_source[i].params.api_version = PPS_API_VERS; + pps_source[i].params.mode = default_params; + init_waitqueue_head(&pps_source[i].queue); + + /* Allocate the PPS source */ + pps_source[i].info = info; + pps_source[i].echo = info->echo; + + /* Register the new tasklet's body and (re)enable it */ + tasklet_init(&pps_source[i].tasklet, pps_tasklet, i); + +pps_register_source_exit : + mutex_unlock(&pps_mutex); + + if (err < 0) + return err; + + ret = pps_sysfs_create_source_entry(info, i); + if (ret < 0) + pps_err("unable to create sysfs entry for source %d", i); + + return i; +} +EXPORT_SYMBOL(pps_register_source); + +void pps_unregister_source(struct pps_source_info_s *info) +{ + int i; + + pps_sysfs_remove_source_entry(info); + + if (mutex_lock_interruptible(&pps_mutex)) + return; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && pps_source[i].info == info) + break; + + if (i >= PPS_MAX_SOURCES) { + pps_err("warning! Try to unregister an unknow PPS source"); + goto pps_unregister_source_exit; + } + + /* Stop any running tasklets */ + tasklet_kill(&pps_source[i].tasklet); + + /* Deallocate the PPS source */ + pps_source[i].info = NULL; + pps_source[i].echo = dummy_echo; + +pps_unregister_source_exit : + mutex_unlock(&pps_mutex); +} +EXPORT_SYMBOL(pps_unregister_source); + +void pps_event(int source, int event, void *data) +{ + struct timespec ts; + + /* First of all we get the time stamp... */ + getnstimeofday(&ts); + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { + pps_err("unknow event (%x) for source %d", event, source); + return; + } + + /* Must call the echo function? + * Note that we don't use the function inside the "info" structure + * since "info" pointer could be NULL! + */ + rmb(); + if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) + pps_source[source].echo(source, event, data); + + /* Save the event data for later and safer time... */ + pps_source[source].event = event; + pps_source[source].ts = ts; + + /* ... then schedule the tasklet */ + tasklet_schedule(&pps_source[source].tasklet); +} +EXPORT_SYMBOL(pps_event); diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c new file mode 100644 index 0000000..49bcc93 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,399 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/version.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/linkage.h> +#include <linux/sched.h> +#include <linux/pps.h> +#include <linux/uaccess.h> + +/* + * Global variables + */ + +struct pps_s pps_source[PPS_MAX_SOURCES]; +DEFINE_MUTEX(pps_mutex); + +/* + * Misc functions + */ + +static void dummy_tasklet(unsigned long data) +{ + /* Nop */ +} + +static inline int pps_check_source(int source) +{ + return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0; +} + +static int pps_find_source(int source) +{ + int i; + + if (source >= 0) { + if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source)) + return -EINVAL; + else + return source; + } + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +static int pps_find_path(char *path) +{ + int i; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && + (strncmp(pps_source[i].info->path, path, + PPS_MAX_NAME_LEN) == 0 || + strncmp(pps_source[i].info->name, path, + PPS_MAX_NAME_LEN) == 0)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +/* + * PPS System Calls + */ + +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg) +{ + struct pps_source_data_s data; + int ret = 0; + + pps_dbg("%s: cmd %d", __FUNCTION__, cmd); + + /* Sanity checks */ + if (_IOC_TYPE(cmd) != 'P') + return -EOPNOTSUPP; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + switch (cmd) { + case PPS_CMD_FIND_SRC : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_SRC: source %d", data.source); + + data.source = pps_find_source(data.source); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + case PPS_CMD_FIND_PATH : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pps_dbg("PPS_CMD_FIND_PATH: path %s", data.path); + + data.source = pps_find_path(data.path); + if (data.source < 0) { + pps_dbg("no PPS devices found"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + default : + pps_err("invalid sys_time_pps_cmd %d", cmd); + ret = -EOPNOTSUPP; + goto sys_time_pps_cmd_exit; + } + + /* Found! So copy the info */ + strncpy(data.name, pps_source[data.source].info->name, + PPS_MAX_NAME_LEN); + strncpy(data.path, pps_source[data.source].info->path, + PPS_MAX_NAME_LEN); + + ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s)); + if (ret) + ret = -EFAULT; + +sys_time_pps_cmd_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params) +{ + int ret = 0; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!params) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getparams_exit; + } + + /* Return current parameters */ + ret = copy_to_user(params, &pps_source[source].params, + sizeof(struct pps_kparams)); + if (ret) + ret = -EFAULT; + +sys_time_pps_getparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Check the capabilities */ + if (!capable(CAP_SYS_TIME)) + return -EPERM; + + /* Sanity checks */ + if (!params) + return -EINVAL; + if ((params->mode & ~pps_source[source].info->mode) != 0) { + pps_dbg("unsupported capabilities"); + return -EINVAL; + } + if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + pps_dbg("capture mode unspecified"); + return -EINVAL; + } + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_setparams_exit; + } + + /* Save the new parameters */ + ret = copy_from_user(&pps_source[source].params, params, + sizeof(struct pps_kparams)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_setparams_exit; + } + + /* Restore the read only parameters */ + if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + /* section 3.3 of RFC 2783 interpreted */ + pps_dbg("time format unspecified"); + pps_source[source].params.mode |= PPS_TSFMT_TSPEC; + } + if (pps_source[source].info->mode & PPS_CANWAIT) + pps_source[source].params.mode |= PPS_CANWAIT; + pps_source[source].params.api_version = PPS_API_VERS; + +sys_time_pps_setparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getcap(int source, int __user *mode) +{ + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + /* Sanity checks */ + if (!mode) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getcap_exit; + } + + ret = put_user(pps_source[source].info->mode, mode); + +sys_time_pps_getcap_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout) +{ + unsigned long ticks; + struct pps_kinfo pi; + struct pps_ktime to; + int ret; + + pps_dbg("%s: source %d", __FUNCTION__, source); + + if (!info) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_fetch_exit; + } + + pps_source[source].go = 0; + + /* Manage the timeout */ + if (timeout) { + ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime)); + if (ret) { + goto sys_time_pps_fetch_exit; + ret = -EFAULT; + } + pps_dbg("timeout %lld.%09d", to.sec, to.nsec); + ticks = to.sec * HZ; + ticks += to.nsec / (NSEC_PER_SEC / HZ); + + if (ticks != 0) { + ret = wait_event_interruptible_timeout( + pps_source[source].queue, + pps_source[source].go, ticks); + if (ret == 0) { + pps_dbg("timeout expired"); + ret = -ETIMEDOUT; + goto sys_time_pps_fetch_exit; + } + } + } else + ret = wait_event_interruptible(pps_source[source].queue, + pps_source[source].go); + + /* Check for pending signals */ + if (ret == -ERESTARTSYS) { + pps_dbg("pending signal caught"); + ret = -EINTR; + goto sys_time_pps_fetch_exit; + } + + /* Return the fetched timestamp */ + pi.assert_sequence = pps_source[source].assert_sequence; + pi.clear_sequence = pps_source[source].clear_sequence; + pi.assert_tu = pps_source[source].assert_tu; + pi.clear_tu = pps_source[source].clear_tu; + pi.current_mode = pps_source[source].current_mode; + ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo)); + if (ret) + ret = -EFAULT; + +sys_time_pps_fetch_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +/* + * Module staff + */ + +static void __exit pps_exit(void) +{ + pps_sysfs_unregister(); + + pps_info("LinuxPPS API ver. %d removed", PPS_API_VERS); +} + +static int __init pps_init(void) +{ + int i, ret; + + /* Init pps_source info */ + for (i = 0; i < PPS_MAX_SOURCES; i++) { + memset(&pps_source[i], 0, sizeof(struct pps_s)); + tasklet_init(&pps_source[i].tasklet, dummy_tasklet, i); + init_waitqueue_head(&pps_source[i].queue); + } + + /* Register to sysfs */ + ret = pps_sysfs_register(); + if (ret < 0) { + pps_err("unable to register sysfs"); + return ret; + } + + pps_info("LinuxPPS API ver. %d registered", PPS_API_VERS); + pps_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti " + "<giometti@linux.it>", PPS_VERSION); + + return 0; +} + +subsys_initcall(pps_init); +module_exit(pps_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..e52dd8e --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,217 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> + +#include <linux/pps.h> + +/* + * Private functions + */ + +static ssize_t pps_show_assert(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->assert_tu.sec, dev->assert_tu.nsec, + dev->assert_sequence); +} + +static ssize_t pps_show_clear(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->clear_tu.sec, dev->clear_tu.nsec, + dev->clear_sequence); +} + +static ssize_t pps_show_mode(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%4x\n", info->mode); +} + +static ssize_t pps_show_echo(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%d\n", !!info->echo); +} + +static ssize_t pps_show_name(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->name); +} + +static ssize_t pps_show_path(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->path); +} + +/* + * Files definitions + */ + +#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \ +{ \ + .attr = { \ + .name = __stringify(_name), \ + .mode = _mode, \ + .owner = THIS_MODULE, \ + }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute pps_class_device_attributes[] = { + DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL), + DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL), + DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL), + DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL), + DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL), + DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL), +}; + +/* + * Class definitions + */ + +static void pps_class_release(struct class_device *cdev) +{ + /* Nop??? */ +} + +static struct class pps_class = { + .name = "pps", + .release = pps_class_release, +}; + +/* + * Public functions + */ + +void pps_sysfs_remove_source_entry(struct pps_source_info_s *info) +{ + int i; + + /* Sanity checks */ + if (info == NULL) + return; + + /* Delete info files */ + if (info->mode&PPS_CAPTUREASSERT) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[0]); + + if (info->mode&PPS_CAPTURECLEAR) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[1]); + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + /* Deregister the pps class */ + class_device_unregister(&info->class_dev); +} + +int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id) +{ + char buf[32]; + int i, ret; + + /* Sanity checks */ + if (info == NULL || id >= PPS_MAX_SOURCES) + return -EINVAL; + + /* Create dir class device name */ + sprintf(buf, "%.02d", id); + + /* Setup the class struct */ + memset(&info->class_dev, 0, sizeof(struct class_device)); + info->class_dev.class = &pps_class; + strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN); + class_set_devdata(&info->class_dev, &pps_source[id]); + + /* Register the new class */ + ret = class_device_register(&info->class_dev); + if (unlikely(ret)) + goto error_class_device_register; + + /* Create info files */ + + /* Create file "assert" and "clear" according to source capability */ + if (info->mode & PPS_CAPTUREASSERT) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[0]); + i = 0; + if (unlikely(ret)) + goto error_class_device_create_file; + } + if (info->mode & PPS_CAPTURECLEAR) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[1]); + i = 1; + if (unlikely(ret)) + goto error_class_device_create_file; + } + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[i]); + if (unlikely(ret)) + goto error_class_device_create_file; + } + + return 0; + +error_class_device_create_file: + while (--i >= 0) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + class_device_unregister(&info->class_dev); + /* Here the release() method was already called */ + +error_class_device_register: + + return ret; +} + +void pps_sysfs_unregister(void) +{ + class_unregister(&pps_class); +} + +int pps_sysfs_register(void) +{ + return class_register(&pps_class); +} diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c index c84dab0..0c9a307 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 326020f..bd12165 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR, + -1 /* PPS ID is up to the system */); + if (ret < 0) { + pps_err("cannot register PPS source \"%s\"", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + pps_info("PPS source #%d \"%s\" added to the system ", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(&state->pps_info); + pps_dbg("PPS source #%d \"%s\" removed from the system", + port->pps_source, state->pps_info.path); +} + +#else + +#define uart_register_pps_port(state, port) do { } while (0) +#define uart_unregister_pps_port(state, port) do { } while (0) + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h index e84ace1..36746dc 100644 --- a/include/asm-i386/unistd.h +++ b/include/asm-i386/unistd.h @@ -329,10 +329,15 @@ #define __NR_signalfd 321 #define __NR_timerfd 322 #define __NR_eventfd 323 +#define __NR_time_pps_cmd 324 +#define __NR_time_pps_getparams 325 +#define __NR_time_pps_setparams 326 +#define __NR_time_pps_getcap 327 +#define __NR_time_pps_fetch 328 #ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 329 #define __ARCH_WANT_IPC_PARSE_VERSION #define __ARCH_WANT_OLD_READDIR diff --git a/include/linux/Kbuild b/include/linux/Kbuild index f317c27..a10d20a 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -293,6 +293,7 @@ unifdef-y += pmu.h unifdef-y += poll.h unifdef-y += ppp_defs.h unifdef-y += ppp-comp.h +unifdef-y += pps.h unifdef-y += ptrace.h unifdef-y += qnx4_fs.h unifdef-y += quota.h diff --git a/include/linux/parport.h b/include/linux/parport.h index 9cdd694..f53d9f4 100644 --- a/include/linux/parport.h +++ b/include/linux/parport.h @@ -100,6 +100,7 @@ typedef enum { #include <linux/proc_fs.h> #include <linux/spinlock.h> #include <linux/wait.h> +#include <linux/pps.h> #include <asm/system.h> #include <asm/ptrace.h> #include <asm/semaphore.h> @@ -327,6 +328,11 @@ struct parport { struct list_head full_list; struct parport *slaves[3]; + +#ifdef CONFIG_PPS_CLIENT_LP + struct pps_source_info_s pps_info; + int pps_source; /* PPS source ID */ +#endif }; #define DEFAULT_SPIN_TIME 500 /* us */ @@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode); /* Lowlevel drivers _can_ call this support function to handle irqs. */ static __inline__ void parport_generic_irq(int irq, struct parport *port) { +#ifdef CONFIG_PPS_CLIENT_LP + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("parport_pc: PPS assert event at %lu on source #%d", + jiffies, port->pps_source); +#endif + parport_ieee1284_interrupt (irq, port); read_lock(&port->cad_lock); if (port->cad && port->cad->irq_func) diff --git a/include/linux/pps.h b/include/linux/pps.h new file mode 100644 index 0000000..901a3b5 --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,213 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +/* Implementation note: the logical states ``assert'' and ``clear'' + * are implemented in terms of the chip register, i.e. ``assert'' + * means the bit is set. */ + +/* + * 3.2 New data structures + */ + +#ifndef __KERNEL__ +#include <linux/types.h> +#include <sys/time.h> +#else +#include <linux/time.h> +#endif + +#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */ +#define PPS_API_VERS PPS_API_VERS_2 +#define LINUXPSS_API 1 /* mark LinuxPPS API */ + +#define PPS_MAX_NAME_LEN 32 + +struct pps_ktime { + __u64 sec; + __u32 nsec; +}; + +struct pps_kinfo { + __u32 assert_sequence; /* seq. num. of assert event */ + __u32 clear_sequence; /* seq. num. of clear event */ + struct pps_ktime assert_tu; /* time of assert event */ + struct pps_ktime clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_kparams { + int api_version; /* API version # */ + int mode; /* mode bits */ + struct pps_ktime assert_off_tu; /* offset compensation for assert */ + struct pps_ktime clear_off_tu; /* offset compensation for clear */ +}; + +/* + * 3.3 Mode bit definitions + */ + +/* Device/implementation parameters */ +#define PPS_CAPTUREASSERT 0x01 /* capture assert events */ +#define PPS_CAPTURECLEAR 0x02 /* capture clear events */ +#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */ + +#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */ +#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */ + +#define PPS_CANWAIT 0x100 /* can we wait for an event? */ +#define PPS_CANPOLL 0x200 /* bit reserved for future use */ + +/* Kernel actions */ +#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */ +#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */ + +/* Timestamp formats */ +#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */ +#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */ + +/* + * 3.4.4 New functions: disciplining the kernel timebase + */ + +/* Kernel consumers */ +#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */ +#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to + use a phase-locked loop */ +#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to + use a frequency-locked loop */ +/* + * Here begins the implementation-specific part! + */ + +#include <linux/ioctl.h> + +struct pps_source_data_s { + int source; + char name[PPS_MAX_NAME_LEN]; + char path[PPS_MAX_NAME_LEN]; +}; + +#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *) +#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *) + +#ifdef __KERNEL__ + +#include <linux/interrupt.h> +#include <linux/device.h> + +/* + * Misc macros + */ + +#define PPS_VERSION "4.0.0-rc4" + +#ifdef CONFIG_PPS_DEBUG +#define pps_dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#else +#define pps_dbg(format, arg...) do {} while (0) +#endif + +#define pps_err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) +#define pps_info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \ + KBUILD_MODNAME , ## arg) + +/* + * Global defines + */ + +#define PPS_MAX_SOURCES 16 + +/* The specific PPS source info */ +struct pps_source_info_s { + char name[PPS_MAX_NAME_LEN]; /* simbolic name */ + char path[PPS_MAX_NAME_LEN]; /* path of connected device */ + int mode; /* PPS's allowed mode */ + + void (*echo)(int source, int event, void *data); /* PPS echo function */ + + /* sysfs section */ + struct class_device class_dev; +}; + +/* The main struct */ +struct pps_s { + struct pps_source_info_s *info; /* PSS source info */ + + struct pps_kparams params; /* PPS's current params */ + + __u32 assert_sequence; /* PPS' assert event seq # */ + __u32 clear_sequence; /* PPS' clear event seq # */ + struct pps_ktime assert_tu; + struct pps_ktime clear_tu; + int current_mode; /* PPS mode at event time */ + + void (*echo)(int source, int event, void *data); /* PPS echo function */ + + int event; /* the last PPS event */ + struct timespec ts; /* the last PPS timestamp */ + struct tasklet_struct tasklet; + + int go; /* PPS event is arrived? */ + wait_queue_head_t queue; /* PPS event queue */ +}; + +/* + * Global variables + */ + +extern struct pps_s pps_source[PPS_MAX_SOURCES]; +extern struct mutex pps_mutex; + +/* + * Global functions + */ + +static inline int pps_is_allocated(int source) +{ + return pps_source[source].info != NULL; +} + +#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev) + +/* + * Exported functions + */ + +extern int pps_register_source(struct pps_source_info_s *info, + int default_params, int try_id); +extern void pps_unregister_source(struct pps_source_info_s *info); +extern void pps_event(int source, int event, void *data); + +extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info, + int id); +extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info); +extern int pps_sysfs_register(void); +extern void pps_sysfs_unregister(void); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 7f2c99d..654ad19 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -153,6 +153,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -232,6 +233,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -276,7 +280,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -308,6 +313,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info_s pps_info; +#endif + struct mutex mutex; }; @@ -472,13 +481,26 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; +#ifdef CONFIG_PPS_CLIENT_UART + struct tty_driver *drv = port->info->tty->driver; -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + pps_dbg("%s%d: PPS assert event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + pps_dbg("%s%d: PPS clear event at %lu on source #%d", + drv->driver_name, port->line, + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 83d0ec1..bfc8899 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -65,6 +65,7 @@ struct getcpu_cache; #include <asm/signal.h> #include <linux/quota.h> #include <linux/key.h> +#include <linux/pps.h> asmlinkage long sys_time(time_t __user *tloc); asmlinkage long sys_stime(time_t __user *tptr); @@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags, const struct itimerspec __user *utmr); asmlinkage long sys_eventfd(unsigned int count); +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg); +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params); +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params); +asmlinkage long sys_time_pps_getcap(int source, int __user *mode); +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout); + int kernel_execve(const char *filename, char *const argv[], char *const envp[]); #endif diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 7e11e2c..e0fccc2 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -148,3 +148,10 @@ cond_syscall(sys_timerfd); cond_syscall(compat_sys_signalfd); cond_syscall(compat_sys_timerfd); cond_syscall(sys_eventfd); + +/* PPS dependent */ +cond_syscall(sys_time_pps_find); +cond_syscall(sys_time_pps_getparams); +cond_syscall(sys_time_pps_setparams); +cond_syscall(sys_time_pps_getcap); +cond_syscall(sys_time_pps_fetch); ^ permalink raw reply related [flat|nested] 43+ messages in thread
* LinuxPPS & spinlocks 2007-07-24 14:52 ` David Woodhouse 2007-07-24 16:01 ` Rodolfo Giometti @ 2007-07-27 18:44 ` Rodolfo Giometti 2007-07-27 19:08 ` Chris Friesen 1 sibling, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-27 18:44 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton [-- Attachment #1: Type: text/plain, Size: 801 bytes --] By looking at spinlocks and thinking better to the lock problems for pps_events() I found this (possible) solution... The pps_event() is now protected by a spinlock against pps_register_source() and pps_unregister_source(), but since I cannot disable IRQs I used the spin_trylock() into the pps_events() so even if the process context holds the lock and an PPS event arrives (IRQ) the system doesn't hang. Note that we cannot lose an event without problems. It could be more acceptable? I removed the "volatile" attribute! :) Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 [-- Attachment #2: proposed_patch --] [-- Type: text/plain, Size: 67887 bytes --] diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile new file mode 100644 index 0000000..a2660a2 --- /dev/null +++ b/Documentation/pps/Makefile @@ -0,0 +1,27 @@ +TARGETS = ppstest ppsctl + +CFLAGS += -Wall -O2 -D_GNU_SOURCE +CFLAGS += -I . +CFLAGS += -ggdb + +# -- Actions section ---------------------------------------------------------- + +.PHONY : all depend dep + +all : .depend $(TARGETS) + +.depend depend dep : + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend + +ifeq (.depend,$(wildcard .depend)) +include .depend +endif + + +# -- Clean section ------------------------------------------------------------ + +.PHONY : clean + +clean : + rm -f *.o *~ core .depend + rm -f ${TARGETS} diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt new file mode 100644 index 0000000..511fa36 --- /dev/null +++ b/Documentation/pps/pps.txt @@ -0,0 +1,211 @@ + + PPS - Pulse Per Second + ---------------------- + +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + + + +Overview +-------- + +LinuxPPS provides a programming interface (API) to define into the +system several PPS sources. + +PPS means "pulse per second" and a PPS source is just a device which +provides a high precision signal each second so that an application +can use it to adjust system clock time. + +A PPS source can be connected to a serial port (usually to the Data +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special +CPU's GPIOs (this is the common case in embedded systems) but in each +case when a new pulse comes the system must apply to it a timestamp +and record it for the userland. + +Common use is the combination of the NTPD as userland program with a +GPS receiver as PPS source to obtain a wallclock-time with +sub-millisecond synchronisation to UTC. + + +RFC considerations +------------------ + +While implementing a PPS API as RFC 2783 defines and using an embedded +CPU GPIO-Pin as physical link to the signal, I encountered a deeper +problem: + + At startup it needs a file descriptor as argument for the function + time_pps_create(). + +This implies that the source has a /dev/... entry. This assumption is +ok for the serial and parallel port, where you can do something +useful besides(!) the gathering of timestamps as it is the central +task for a PPS-API. But this assumption does not work for a single +purpose GPIO line. In this case even basic file-related functionality +(like read() and write()) makes no sense at all and should not be a +precondition for the use of a PPS-API. + +The problem can be simply solved if you change the original RFC 2783: + + pps_handle_t type is an opaque __scalar type__ used to represent a + PPS source within the API + +into a modified: + + pps_handle_t type is an opaque __variable__ used to represent a PPS + source within the API and programs should not access it directly to + it due to its opacity. + +This change seems to be neglibile because even the original RFC 2783 +does not encourage programs to check (read: use) the pps_handle_t +variable before calling the time_pps_*() functions, since each +function should do this job internally. + +If I intentionally separate the concept of "file descriptor" from the +concept of the "PPS source" I'm obliged to provide a solution to find +and register a PPS-source without using a file descriptor: it's done +by the functions time_pps_findsource() and time_pps_findpath() now. + +According to this current NTPD drivers' code should be modified as +follows: + ++#ifdef PPS_HAVE_FINDPATH ++ /* Get the PPS source's real name */ ++ fd = readlink(link, path, STRING_LEN-1); ++ if (fd <= 0) ++ strncpy(path, link, STRING_LEN); ++ else ++ path[fd] = '\0'; ++ ++ /* Try to find the source */ ++ fd = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); ++ if (fd < 0) { ++ msyslog(LOG_ERR, "refclock: cannot find PPS source \"%s\" " ++ "in the system", path); ++ return 1; ++ } ++ msyslog(LOG_INFO, "refclock: found PPS source #%d \"%s\" on \"%s\"", ++ fd, path, id); ++#endif /* PPS_HAVE_FINDPATH */ ++ ++ + if (time_pps_create(fd, &pps_handle) < 0) { +- pps_handle = 0; + msyslog(LOG_ERR, "refclock: time_pps_create failed: %m"); + } + + +Coding example +-------------- + +To register a PPS source into the kernel you should define a struct +pps_source_info_s as follow: + + static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, + }; + +and then calling the function pps_register_source() in your +intialization routine as follow: + + source = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + +The pps_register_source() prototype is: + + int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) + +where "info" is a pointer to a structure that describes a particular +PPS source, "default_params" tells the system what the initial default +parameters for the device should be (is obvious that these parameters +must be a subset of ones defined into the struct +pps_source_info_s which describe the capabilities of the driver) +and "try_id" can be used to force a particular ID for your device into +the system (just use -1 if you wish the system chooses one for you). + +Once you have registered a new PPS source into the system you can +signal an assert event (for example in the interrupt handler routine) +just using: + + pps_event(source, PPS_CAPTUREASSERT, ptr); + +The same function may also run the defined echo function +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user +asked for that... etc.. + +Please see the file drivers/pps/clients/ktimer.c for an example code. + + +SYSFS support +------------- + +The SYSFS support is enabled by default if the SYSFS filesystem is +enabled in the kernel and it provides a new class: + + $ ls /sys/class/pps/ + 00/ 01/ 02/ + +Every directory is the ID of a PPS sources defined into the system and +inside you find several files: + + $ ls /sys/class/pps/00/ + assert clear echo mode name path subsystem@ uevent + +Inside each "assert" and "clear" file you can find the timestamp and a +sequence number: + + $ cat /sys/class/pps/00/assert + 1170026870.983207967#8 + +Where before the "#" is the timestamp in seconds and after it is the +sequence number. Other files are: + +* echo: reports if the PPS source has an echo function or not; + +* mode: reports available PPS functioning modes; + +* name: reports the PPS source's name; + +* path: reports the PPS source's device path, that is the device the + PPS source is connected to (if it exists). + + +Testing the PPS support +----------------------- + +In order to test the PPS support even without specific hardware you can use +the ktimer driver (see the client subsection in the PPS configuration menu) +and the userland tools provided into Documentaion/pps/ directory. + +Once you have enabled the compilation of ktimer just modprobe it (if +not statically compiled): + + # modprobe ktimer + +and the run ppstest as follow: + + $ ./ppstest + found PPS source #0 "ktimer" on "" + ok, found 1 source(s), now start fetching data... + source 0 - assert 1183041017.838928410, sequence: 2 - clear 0.000000000, sequence: 0 + source 0 - assert 1183041018.839023954, sequence: 3 - clear 0.000000000, sequence: 0 + +Please, note that to compile userland programs you need the file timepps.h +(see Documentation/pps/). diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c new file mode 100644 index 0000000..17afcbd --- /dev/null +++ b/Documentation/pps/ppsctl.c @@ -0,0 +1,61 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <string.h> +#include <linux/serial.h> + +void usage(char *name) +{ + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name); + + exit(EXIT_FAILURE); +} + +int main(int argc, char *argv[]) +{ + int fd, ret; + struct serial_struct ss; + + if (argc < 2) + usage(argv[0]); + + fd = open(argv[1], O_RDWR); + if (fd < 0) { + perror("open"); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCGSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCGSERIAL)"); + exit(EXIT_FAILURE); + } + + if (argc < 3) { /* just read PPS status */ + printf("PPS is %sabled\n", + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis"); + exit(EXIT_SUCCESS); + } + + if (argv[2][0] == 'e' || argv[2][0] == '1') + ss.flags |= ASYNC_HARDPPS_CD; + else if (argv[2][0] == 'd' || argv[2][0] == '0') + ss.flags &= ~ASYNC_HARDPPS_CD; + else { + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]); + exit(EXIT_FAILURE); + } + + ret = ioctl(fd, TIOCSSERIAL, &ss); + if (ret < 0) { + perror("ioctl(TIOCSSERIAL)"); + exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c new file mode 100644 index 0000000..bfd1064 --- /dev/null +++ b/Documentation/pps/ppstest.c @@ -0,0 +1,201 @@ +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <timepps.h> + +#define STRING_LEN PPS_MAX_NAME_LEN + +int find_source(int try_link, char *link, pps_handle_t *handle, + int *avail_mode) +{ + int num = -1; + char id[STRING_LEN] = "", /* no ID string by default */ + path[STRING_LEN]; + pps_params_t params; + int ret; + + if (try_link) { + printf("trying PPS source \"%s\"\n", link); +#ifdef PPS_HAVE_FINDPATH + /* Get the PPS source's real name */ + time_pps_readlink(link, STRING_LEN, path, STRING_LEN); + + /* Try to find the source by using the supplied "path" name */ + ret = time_pps_findpath(path, STRING_LEN, id, STRING_LEN); + if (ret < 0) + goto exit; + num = ret; +#else +#warning "cannot use time_pps_findpath()" + ret = -1; +#endif /* PPS_HAVE_FINDPATH */ + } +#ifdef PPS_HAVE_FINDSOURCE + /* Try to find the source (by using "index = -1" we ask just + * for a generic source) */ + ret = time_pps_findsource(num, path, STRING_LEN, id, STRING_LEN); +#else +#warning "cannot use time_pps_findsource()" + ret = -1; +#endif /* PPS_HAVE_FINDSOURCE */ + if (ret < 0) { +exit: + fprintf(stderr, "no available PPS source in the system\n"); + return -1; + } + num = ret; + printf("found PPS source #%d \"%s\" on \"%s\"\n", num, id, path); + + /* If "path" is not NULL we should *at least* open the pointed + * device in order to enable the interrupts generation. + * Note that this can be NOT enough anyway, infact you may need sending + * additional commands to your GPS antenna before it starts sending + * the PPS signal. */ + if (strlen(path)) { + ret = open(path, O_RDWR); + if (ret < 0) { + fprintf(stderr, "cannot open \"%s\" (%m)\n", path); + return -1; + } + } + + /* Open the PPS source */ + ret = time_pps_create(num, handle); + if (ret < 0) { + fprintf(stderr, "cannot create a PPS source (%m)\n"); + return -1; + } + + /* Find out what features are supported */ + ret = time_pps_getcap(*handle, avail_mode); + if (ret < 0) { + fprintf(stderr, "cannot get capabilities (%m)\n"); + return -1; + } + if ((*avail_mode & PPS_CAPTUREASSERT) == 0) { + fprintf(stderr, "cannot CAPTUREASSERT\n"); + return -1; + } + if ((*avail_mode & PPS_OFFSETASSERT) == 0) { + fprintf(stderr, "cannot OFFSETASSERT\n"); + return -1; + } + + /* Capture assert timestamps, and compensate for a 675 nsec + * propagation delay */ + ret = time_pps_getparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot get parameters (%m)\n"); + return -1; + } + params.assert_offset.tv_sec = 0; + params.assert_offset.tv_nsec = 675; + params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT; + ret = time_pps_setparams(*handle, ¶ms); + if (ret < 0) { + fprintf(stderr, "cannot set parameters (%m)\n"); + return -1; + } + + return 0; +} + +int fetch_source(int i, pps_handle_t *handle, int *avail_mode) +{ + struct timespec timeout; + pps_info_t infobuf; + int ret; + + /* create a zero-valued timeout */ + timeout.tv_sec = 3; + timeout.tv_nsec = 0; + +retry: + if (*avail_mode & PPS_CANWAIT) { + /* waits for the next event */ + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } else { + sleep(1); + ret = + time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf, + &timeout); + } + if (ret < 0) { + if (ret == -EINTR) { + fprintf(stderr, "time_pps_fetch() got a signal!\n"); + goto retry; + } + + fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret); + return -1; + } + + printf("source %d - " + "assert %ld.%09ld, sequence: %ld - " + "clear %ld.%09ld, sequence: %ld\n", + i, + infobuf.assert_timestamp.tv_sec, + infobuf.assert_timestamp.tv_nsec, + infobuf.assert_sequence, + infobuf.clear_timestamp.tv_sec, + infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int num, try_link = 0; /* by default use findsource */ + char link[STRING_LEN] = "/dev/gps0"; /* just a default device */ + pps_handle_t handle[4]; + int avail_mode[4]; + int i = 0, ret; + + if (argc == 1) { + ret = find_source(try_link, link, &handle[0], &avail_mode[0]); + if (ret < 0) + exit(EXIT_FAILURE); + + num = 1; + } else { + for (i = 1; i < argc && i <= 4; i++) { + ret = sscanf(argv[i], "%d", &num); + if (ret < 1) { + try_link = ~0; + strncpy(link, argv[i], STRING_LEN); + } + + ret = + find_source(try_link, link, &handle[i - 1], + &avail_mode[i - 1]); + if (ret < 0) + exit(EXIT_FAILURE); + } + + num = i - 1; + } + + printf("ok, found %d source(s), now start fetching data...\n", num); + + /* loop, printing the most recent timestamp every second or so */ + while (1) { + for (i = 0; i < num; i++) { + ret = fetch_source(i, &handle[i], &avail_mode[i]); + if (ret < 0 && errno != ETIMEDOUT) + exit(EXIT_FAILURE); + } + } + + for (; i >= 0; i--) + time_pps_destroy(handle[i]); + + return 0; +} diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h new file mode 100644 index 0000000..dee1782 --- /dev/null +++ b/Documentation/pps/timepps.h @@ -0,0 +1,234 @@ +/* + * timepps.h -- PPS API main header + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _SYS_TIMEPPS_H_ +#define _SYS_TIMEPPS_H_ + +#include <sys/syscall.h> +#include <unistd.h> +#include <errno.h> +#include <linux/pps.h> + +/* + * New data structures + */ + +struct ntp_fp { + unsigned int integral; + unsigned int fractional; +}; + +union pps_timeu { + struct timespec tspec; + struct ntp_fp ntpfp; + unsigned long longpad[3]; +}; + +struct pps_info { + unsigned long assert_sequence; /* seq. num. of assert event */ + unsigned long clear_sequence; /* seq. num. of clear event */ + union pps_timeu assert_tu; /* time of assert event */ + union pps_timeu clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_params { + int api_version; /* API version # */ + int mode; /* mode bits */ + union pps_timeu assert_off_tu; /* offset compensation for assert */ + union pps_timeu clear_off_tu; /* offset compensation for clear */ +}; + +typedef int pps_handle_t; /* represents a PPS source */ +typedef unsigned long pps_seq_t; /* sequence number */ +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */ +typedef union pps_timeu pps_timeu_t; /* generic data type to represent time stamps */ +typedef struct pps_info pps_info_t; +typedef struct pps_params pps_params_t; + +#define assert_timestamp assert_tu.tspec +#define clear_timestamp clear_tu.tspec + +#define assert_timestamp_ntpfp assert_tu.ntpfp +#define clear_timestamp_ntpfp clear_tu.ntpfp + +#define assert_offset assert_off_tu.tspec +#define clear_offset clear_off_tu.tspec + +#define assert_offset_ntpfp assert_off_tu.ntpfp +#define clear_offset_ntpfp clear_off_tu.ntpfp + +/* + * The PPS API + */ + +#define PPS_HAVE_FINDSOURCE 1 +#define pps_min(a, b) (a) < (b) ? a : b +int time_pps_findsource(int index, char *path, int pathlen, char *idstring, + int idlen) +{ + struct pps_source_data_s data; + int ret; + + data.source = index; + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_SRC, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + strncpy(path, data.path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +/* Defined iff PPS_HAVE_FINDPATH is defined */ +void time_pps_readlink(char *link, int linklen, char *path, int pathlen) +{ + int i; + + i = readlink(link, path, pathlen - 1); + if (i <= 0) { + /* "link" is not a valid symbolic so we directly use it */ + strncpy(path, link, linklen <= pathlen ? linklen : pathlen); + return; + } + + /* Return the file name where "link" points to */ + path[i] = '\0'; +} + +#define PPS_HAVE_FINDPATH 1 +int time_pps_findpath(char *path, int pathlen, char *idstring, int idlen) +{ + struct pps_source_data_s data; + int ret; + + strncpy(data.path, path, pps_min(pathlen, PPS_MAX_NAME_LEN)); + + ret = syscall(__NR_time_pps_cmd, PPS_CMD_FIND_PATH, &data); + if (ret < 0) + return ret; + + strncpy(idstring, data.name, pps_min(idlen, PPS_MAX_NAME_LEN)); + + return data.source; +} + +int time_pps_create(int source, pps_handle_t *handle) +{ + if (!handle) { + errno = EINVAL; + return -1; + } + + /* In LinuxPPS there are no differences between a PPS source and + * a PPS handle so we return the same value. + */ + *handle = source; + + return 0; +} + +int time_pps_destroy(pps_handle_t handle) +{ + /* Nothing to destroy here */ + + return 0; +} + +int time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams) +{ + int ret; + struct pps_kparams __ppsparams; + + ret = syscall(__NR_time_pps_getparams, handle, &__ppsparams); + + ppsparams->api_version = __ppsparams.api_version; + ppsparams->mode = __ppsparams.mode; + ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec; + ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec; + ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec; + ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec; + + return ret; +} + +int time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams) +{ + struct pps_kparams __ppsparams; + + __ppsparams.api_version = ppsparams->api_version; + __ppsparams.mode = ppsparams->mode; + __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec; + __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec; + __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec; + __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec; + + return syscall(__NR_time_pps_getparams, handle, &__ppsparams); +} + +/* Get capabilities for handle */ +int time_pps_getcap(pps_handle_t handle, int *mode) +{ + return syscall(__NR_time_pps_getcap, handle, mode); +} + +int time_pps_fetch(pps_handle_t handle, const int tsformat, + pps_info_t *ppsinfobuf, const struct timespec *timeout) +{ + struct pps_kinfo __ppsinfobuf; + struct pps_ktime __timeout; + int ret; + + /* Sanity checks */ + if (tsformat != PPS_TSFMT_TSPEC) { + errno = EINVAL; + return -1; + } + + if (timeout) { + __timeout.sec = timeout->tv_sec; + __timeout.nsec = timeout->tv_nsec; + } + + ret = syscall(__NR_time_pps_fetch, handle, &__ppsinfobuf, + timeout ? &__timeout : NULL); + + ppsinfobuf->assert_sequence = __ppsinfobuf.assert_sequence; + ppsinfobuf->clear_sequence = __ppsinfobuf.clear_sequence; + ppsinfobuf->assert_tu.tspec.tv_sec = __ppsinfobuf.assert_tu.sec; + ppsinfobuf->assert_tu.tspec.tv_nsec = __ppsinfobuf.assert_tu.nsec; + ppsinfobuf->clear_tu.tspec.tv_sec = __ppsinfobuf.clear_tu.sec; + ppsinfobuf->clear_tu.tspec.tv_nsec = __ppsinfobuf.clear_tu.nsec; + ppsinfobuf->current_mode = __ppsinfobuf.current_mode; + + return ret; +} + +int time_pps_kcbind(pps_handle_t handle, const int kernel_consumer, + const int edge, const int tsformat) +{ + /* LinuxPPS doesn't implement kernel consumer feature */ + errno = EOPNOTSUPP; + return -1; +} + +#endif /* _SYS_TIMEPPS_H_ */ diff --git a/MAINTAINERS b/MAINTAINERS index df40a4e..17e9a02 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2903,6 +2903,13 @@ P: Michal Ostrowski M: mostrows@speakeasy.net S: Maintained +PPS SUPPORT +P: Rodolfo Giometti +M: giometti@enneenne.com +W: http://wiki.enneenne.com/index.php/LinuxPPS_support +L: linuxpps@ml.enneenne.com +S: Maintained + PREEMPTIBLE KERNEL P: Robert Love M: rml@tech9.net diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S index bf6adce..f1bf4ff 100644 --- a/arch/i386/kernel/syscall_table.S +++ b/arch/i386/kernel/syscall_table.S @@ -323,3 +323,8 @@ ENTRY(sys_call_table) .long sys_signalfd .long sys_timerfd .long sys_eventfd + .long sys_time_pps_cmd + .long sys_time_pps_getparams /* 325 */ + .long sys_time_pps_setparams + .long sys_time_pps_getcap + .long sys_time_pps_fetch diff --git a/drivers/Kconfig b/drivers/Kconfig index 050323f..bb54cab 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig" source "drivers/spi/Kconfig" +source "drivers/pps/Kconfig" + source "drivers/w1/Kconfig" source "drivers/hwmon/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index adad2f3..985d495 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_I2O) += message/ obj-$(CONFIG_RTC_LIB) += rtc/ obj-y += i2c/ +obj-$(CONFIG_PPS) += pps/ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/ obj-$(CONFIG_PHONE) += telephony/ diff --git a/drivers/char/lp.c b/drivers/char/lp.c index 62051f8..8b2e41f 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -746,6 +746,27 @@ static struct console lpcons = { #endif /* console on line printer */ +/* Support for PPS signal on the line printer */ + +#ifdef CONFIG_PPS_CLIENT_LP + +static void lp_pps_echo(int source, int event, void *data) +{ + struct parport *port = data; + unsigned char status = parport_read_status(port); + + /* echo event via SEL bit */ + parport_write_control(port, + parport_read_control(port) | PARPORT_CONTROL_SELECT); + + /* signal no event */ + if ((status & PARPORT_STATUS_ACK) != 0) + parport_write_control(port, + parport_read_control(port) & ~PARPORT_CONTROL_SELECT); +} + +#endif + /* --- initialisation code ------------------------------------- */ static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC }; @@ -817,6 +838,37 @@ static int lp_register(int nr, struct parport *port) } #endif +#ifdef CONFIG_PPS_CLIENT_LP + snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr); + + /* No PPS support if lp port has no IRQ line */ + if (port->irq != PARPORT_IRQ_NONE) { + strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN); + + port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + port->pps_info.echo = lp_pps_echo; + + port->pps_source = pps_register_source(&(port->pps_info), + PPS_CAPTUREASSERT | PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (port->pps_source < 0) + dev_err(port->dev, + "cannot register PPS source \"%s\"\n", + port->pps_info.path); + else + dev_info(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, port->pps_info.path); + } else { + port->pps_source = -1; + dev_err(port->dev, "PPS support disabled due port \"%s\" is " + "in polling mode\n", + port->pps_info.path); + } +#endif + return 0; } @@ -860,6 +912,14 @@ static void lp_detach (struct parport *port) console_registered = NULL; } #endif /* CONFIG_LP_CONSOLE */ + +#ifdef CONFIG_PPS_CLIENT_LP + if (port->pps_source >= 0) { + pps_unregister_source(&(port->pps_info)); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, port->pps_info.path); + } +#endif } static struct parport_driver lp_driver = { diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig new file mode 100644 index 0000000..a00b59a --- /dev/null +++ b/drivers/pps/Kconfig @@ -0,0 +1,31 @@ +# +# PPS support configuration +# + +menu "PPS support" + +config PPS + bool "PPS support" + depends on EXPERIMENTAL + ---help--- + PPS (Pulse Per Second) is a special pulse provided by some GPS + antennae. Userland can use it to get an high time reference. + + Some antennae's PPS signals are connected with the CD (Carrier + Detect) pin of the serial line they use to communicate with the + host. In this case use the SERIAL_LINE client support. + + Some antennae's PPS signals are connected with some special host + inputs so you have to enable the corresponding client support. + +config PPS_DEBUG + bool "PPS debugging messages" + depends on PPS + help + Say Y here if you want the PPS support to produce a bunch of debug + messages to the system log. Select this if you are having a + problem with PPS support and want to see more of what is going on. + +source drivers/pps/clients/Kconfig + +endmenu diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile new file mode 100644 index 0000000..d8ec308 --- /dev/null +++ b/drivers/pps/Makefile @@ -0,0 +1,11 @@ +# +# Makefile for the PPS core. +# + +pps_core-objs += pps.o kapi.o sysfs.o +obj-$(CONFIG_PPS) += pps_core.o +obj-y += clients/ + +ifeq ($(CONFIG_PPS_DEBUG),y) +EXTRA_CFLAGS += -DDEBUG +endif diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig new file mode 100644 index 0000000..58a1e55 --- /dev/null +++ b/drivers/pps/clients/Kconfig @@ -0,0 +1,30 @@ +# +# PPS clients configuration +# + +if PPS + +comment "PPS clients support" + +config PPS_CLIENT_KTIMER + tristate "Kernel timer client (Testing client, use for debug)" + help + If you say yes here you get support for a PPS debugging client + which uses a kernel timer to generate the PPS signal. + + This driver can also be built as a module. If so, the module + will be called ktimer.ko. + +config PPS_CLIENT_UART + bool "UART serial support" + help + If you say yes here you get support for a PPS source connected + with the CD (Carrier Detect) pin of your serial port. + +config PPS_CLIENT_LP + bool "Parallel printer support" + help + If you say yes here you get support for a PPS source connected + with the interrupt pin of your parallel port. + +endif diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile new file mode 100644 index 0000000..f3c1e39 --- /dev/null +++ b/drivers/pps/clients/Makefile @@ -0,0 +1,9 @@ +# +# Makefile for PPS clients. +# + +obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o + +ifeq ($(CONFIG_PPS_DEBUG),y) +EXTRA_CFLAGS += -DDEBUG +endif diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c new file mode 100644 index 0000000..c5d83f5 --- /dev/null +++ b/drivers/pps/clients/ktimer.c @@ -0,0 +1,114 @@ +/* + * ktimer.c -- kernel timer test client + * + * + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/time.h> +#include <linux/timer.h> + +#include <linux/pps.h> + +/* + * Global variables + */ + +static int source; +static struct timer_list ktimer; + +/* + * The kernel timer + */ + +static void pps_ktimer_event(unsigned long ptr) +{ + pr_info("PPS event at %lu\n", jiffies); + + pps_event(source, PPS_CAPTUREASSERT, NULL); + + mod_timer(&ktimer, jiffies + HZ); +} + +/* + * The echo function + */ + +static void pps_ktimer_echo(int source, int event, void *data) +{ + pr_info("echo %s %s for source %d\n", + event & PPS_CAPTUREASSERT ? "assert" : "", + event & PPS_CAPTURECLEAR ? "clear" : "", + source); +} + +/* + * The PPS info struct + */ + +static struct pps_source_info_s pps_ktimer_info = { + name : "ktimer", + path : "", + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \ + PPS_ECHOASSERT | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC, + echo : pps_ktimer_echo, +}; + +/* + * Module staff + */ + +static void __exit pps_ktimer_exit(void) +{ + del_timer_sync(&ktimer); + pps_unregister_source(&pps_ktimer_info); + + pr_info("ktimer PPS source unregistered\n"); +} + +static int __init pps_ktimer_init(void) +{ + int ret; + + ret = pps_register_source(&pps_ktimer_info, + PPS_CAPTUREASSERT|PPS_OFFSETASSERT, + -1 /* is up to the system */); + if (ret < 0) { + printk(KERN_ERR "cannot register ktimer source\n"); + return ret; + } + source = ret; + + setup_timer(&ktimer, pps_ktimer_event, 0); + mod_timer(&ktimer, jiffies + HZ); + + pr_info("ktimer PPS source registered at %d\n", source); + + return 0; +} + +module_init(pps_ktimer_init); +module_exit(pps_ktimer_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)"); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c new file mode 100644 index 0000000..7aa32c6 --- /dev/null +++ b/drivers/pps/kapi.c @@ -0,0 +1,222 @@ +/* + * kapi.c -- kernel API + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/time.h> +#include <linux/spinlock.h> +#include <linux/pps.h> + +/* + * Local variables + */ + +static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED; + +/* + * Local functions + */ + +static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset) +{ + ts->nsec += offset->nsec; + if (ts->nsec >= NSEC_PER_SEC) { + ts->nsec -= NSEC_PER_SEC; + ts->sec++; + } else if (ts->nsec < 0) { + ts->nsec += NSEC_PER_SEC; + ts->sec--; + } + ts->sec += offset->sec; +} + +/* + * Exported functions + */ + +int pps_register_source(struct pps_source_info_s *info, int default_params, + int try_id) +{ + int i = -1, err = 0, ret; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + if (try_id >= 0) { + if (pps_is_allocated(try_id)) { + printk(KERN_ERR "source id %d busy\n", try_id); + err = -EBUSY; + goto pps_register_source_exit; + } + i = try_id; + } else { + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (!pps_is_allocated(i)) + break; + if (i >= PPS_MAX_SOURCES) { + printk(KERN_ERR "no free source IDs\n"); + err = -ENOMEM; + goto pps_register_source_exit; + } + } + + /* Sanity checks */ + if ((info->mode & default_params) != default_params) { + printk(KERN_ERR "unsupported default parameters\n"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 && + info->echo == NULL) { + printk(KERN_ERR "echo function is not defined\n"); + err = -EINVAL; + goto pps_register_source_exit; + } + if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + printk(KERN_ERR "unspecified time format\n"); + err = -EINVAL; + goto pps_register_source_exit; + } + + spin_lock(&pps_lock); + + /* Init the PPS source main struct */ + memset(&pps_source[i], 0, sizeof(struct pps_s)); + pps_source[i].params.api_version = PPS_API_VERS; + pps_source[i].params.mode = default_params; + init_waitqueue_head(&pps_source[i].queue); + pps_source[i].info = info; + + spin_unlock(&pps_lock); + +pps_register_source_exit : + mutex_unlock(&pps_mutex); + + if (err < 0) + return err; + + ret = pps_sysfs_create_source_entry(info, i); + if (ret < 0) + printk(KERN_ERR "unable to create sysfs entry for source %d\n", + i); + + return i; +} +EXPORT_SYMBOL(pps_register_source); + +void pps_unregister_source(struct pps_source_info_s *info) +{ + int i; + + pps_sysfs_remove_source_entry(info); + + if (mutex_lock_interruptible(&pps_mutex)) + return; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && pps_source[i].info == info) + break; + + if (i >= PPS_MAX_SOURCES) { + printk(KERN_ERR "warning! Try to unregister an unknown " + "PPS source\n"); + goto pps_unregister_source_exit; + } + + spin_lock(&pps_lock); + + /* Deallocate the PPS source */ + memset(&pps_source[i], 0, sizeof(struct pps_s)); + + spin_unlock(&pps_lock); + +pps_unregister_source_exit : + mutex_unlock(&pps_mutex); +} +EXPORT_SYMBOL(pps_unregister_source); + +void pps_event(int source, int event, void *data) +{ + struct timespec __ts; + struct pps_ktime ts; + + /* First of all we get the time stamp... */ + getnstimeofday(&__ts); + + /* ... and translate it to PPS time data struct */ + ts.sec = __ts.tv_sec; + ts.nsec = __ts.tv_nsec; + + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) { + printk(KERN_ERR "unknown event (%x) for source %d\n", + event, source); + return; + } + + /* Try to grab the lock, if not we prefere loose the event... */ + if (!spin_trylock(&pps_lock)) + return; + + if (!pps_source[source].info) { + spin_unlock(&pps_lock); + return; + } + + /* Must call the echo function? */ + if ((pps_source[source].params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) + pps_source[source].info->echo(source, event, data); + + /* Check the event */ + pps_source[source].current_mode = pps_source[source].params.mode; + if (event & PPS_CAPTUREASSERT) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETASSERT) + pps_add_offset(&ts, + &pps_source[source].params.assert_off_tu); + + /* Save the time stamp */ + pps_source[source].assert_tu = ts; + pps_source[source].assert_sequence++; + pr_debug("capture assert seq #%u for source %d\n", + pps_source[source].assert_sequence, source); + } + if (event & PPS_CAPTURECLEAR) { + /* We have to add an offset? */ + if (pps_source[source].params.mode & PPS_OFFSETCLEAR) + pps_add_offset(&ts, + &pps_source[source].params.clear_off_tu); + + /* Save the time stamp */ + pps_source[source].clear_tu = ts; + pps_source[source].clear_sequence++; + pr_debug("capture clear seq #%u for source %d\n", + pps_source[source].clear_sequence, source); + } + + pps_source[source].go = ~0; + wake_up_interruptible(&pps_source[source].queue); + + spin_unlock(&pps_lock); +} +EXPORT_SYMBOL(pps_event); diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c new file mode 100644 index 0000000..9176c01 --- /dev/null +++ b/drivers/pps/pps.c @@ -0,0 +1,391 @@ +/* + * pps.c -- Main PPS support file + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/version.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/linkage.h> +#include <linux/sched.h> +#include <linux/pps.h> +#include <linux/uaccess.h> + +/* + * Global variables + */ + +struct pps_s pps_source[PPS_MAX_SOURCES]; +DEFINE_MUTEX(pps_mutex); + +/* + * Misc functions + */ + +static inline int pps_check_source(int source) +{ + return (source < 0 || !pps_is_allocated(source)) ? -EINVAL : 0; +} + +static int pps_find_source(int source) +{ + int i; + + if (source >= 0) { + if (source >= PPS_MAX_SOURCES || !pps_is_allocated(source)) + return -EINVAL; + else + return source; + } + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +static int pps_find_path(char *path) +{ + int i; + + for (i = 0; i < PPS_MAX_SOURCES; i++) + if (pps_is_allocated(i) && + (strncmp(pps_source[i].info->path, path, + PPS_MAX_NAME_LEN) == 0 || + strncmp(pps_source[i].info->name, path, + PPS_MAX_NAME_LEN) == 0)) + break; + + if (i >= PPS_MAX_SOURCES) + return -EINVAL; + + return i; +} + +/* + * PPS System Calls + */ + +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg) +{ + struct pps_source_data_s data; + int ret = 0; + + pr_debug("%s: cmd %d\n", __FUNCTION__, cmd); + + /* Sanity checks */ + if (_IOC_TYPE(cmd) != 'P') + return -EOPNOTSUPP; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + switch (cmd) { + case PPS_CMD_FIND_SRC : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pr_debug("PPS_CMD_FIND_SRC: source %d\n", data.source); + + data.source = pps_find_source(data.source); + if (data.source < 0) { + pr_debug("no PPS devices found\n"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + case PPS_CMD_FIND_PATH : + ret = copy_from_user(&data, arg, + sizeof(struct pps_source_data_s)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_cmd_exit; + } + + pr_debug("PPS_CMD_FIND_PATH: path %s\n", data.path); + + data.source = pps_find_path(data.path); + if (data.source < 0) { + pr_debug("no PPS devices found\n"); + ret = -ENODEV; + goto sys_time_pps_cmd_exit; + } + + break; + + default : + printk(KERN_ERR "invalid sys_time_pps_cmd %d\n", cmd); + ret = -EOPNOTSUPP; + goto sys_time_pps_cmd_exit; + } + + /* Found! So copy the info */ + strncpy(data.name, pps_source[data.source].info->name, + PPS_MAX_NAME_LEN); + strncpy(data.path, pps_source[data.source].info->path, + PPS_MAX_NAME_LEN); + + ret = copy_to_user(arg, &data, sizeof(struct pps_source_data_s)); + if (ret) + ret = -EFAULT; + +sys_time_pps_cmd_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params) +{ + int ret = 0; + + pr_debug("%s: source %d\n", __FUNCTION__, source); + + /* Sanity checks */ + if (!params) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getparams_exit; + } + + /* Return current parameters */ + ret = copy_to_user(params, &pps_source[source].params, + sizeof(struct pps_kparams)); + if (ret) + ret = -EFAULT; + +sys_time_pps_getparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params) +{ + int ret; + + pr_debug("%s: source %d\n", __FUNCTION__, source); + + /* Check the capabilities */ + if (!capable(CAP_SYS_TIME)) + return -EPERM; + + /* Sanity checks */ + if (!params) + return -EINVAL; + if ((params->mode & ~pps_source[source].info->mode) != 0) { + pr_debug("unsupported capabilities\n"); + return -EINVAL; + } + if ((params->mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { + pr_debug("capture mode unspecified\n"); + return -EINVAL; + } + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_setparams_exit; + } + + /* Save the new parameters */ + ret = copy_from_user(&pps_source[source].params, params, + sizeof(struct pps_kparams)); + if (ret) { + ret = -EFAULT; + goto sys_time_pps_setparams_exit; + } + + /* Restore the read only parameters */ + if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + /* section 3.3 of RFC 2783 interpreted */ + pr_debug("time format unspecified\n"); + pps_source[source].params.mode |= PPS_TSFMT_TSPEC; + } + if (pps_source[source].info->mode & PPS_CANWAIT) + pps_source[source].params.mode |= PPS_CANWAIT; + pps_source[source].params.api_version = PPS_API_VERS; + +sys_time_pps_setparams_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_getcap(int source, int __user *mode) +{ + int ret; + + pr_debug("%s: source %d\n", __FUNCTION__, source); + + /* Sanity checks */ + if (!mode) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_getcap_exit; + } + + ret = put_user(pps_source[source].info->mode, mode); + +sys_time_pps_getcap_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout) +{ + unsigned long ticks; + struct pps_kinfo pi; + struct pps_ktime to; + int ret; + + pr_debug("%s: source %d\n", __FUNCTION__, source); + + if (!info) + return -EINVAL; + + if (mutex_lock_interruptible(&pps_mutex)) + return -EINTR; + + ret = pps_check_source(source); + if (ret < 0) { + ret = -ENODEV; + goto sys_time_pps_fetch_exit; + } + + pps_source[source].go = 0; + + /* Manage the timeout */ + if (timeout) { + ret = copy_from_user(&to, timeout, sizeof(struct pps_ktime)); + if (ret) { + goto sys_time_pps_fetch_exit; + ret = -EFAULT; + } + pr_debug("timeout %lld.%09d\n", to.sec, to.nsec); + ticks = to.sec * HZ; + ticks += to.nsec / (NSEC_PER_SEC / HZ); + + if (ticks != 0) { + ret = wait_event_interruptible_timeout( + pps_source[source].queue, + pps_source[source].go, ticks); + if (ret == 0) { + pr_debug("timeout expired\n"); + ret = -ETIMEDOUT; + goto sys_time_pps_fetch_exit; + } + } + } else + ret = wait_event_interruptible(pps_source[source].queue, + pps_source[source].go); + + /* Check for pending signals */ + if (ret == -ERESTARTSYS) { + pr_debug("pending signal caught\n"); + ret = -EINTR; + goto sys_time_pps_fetch_exit; + } + + /* Return the fetched timestamp */ + pi.assert_sequence = pps_source[source].assert_sequence; + pi.clear_sequence = pps_source[source].clear_sequence; + pi.assert_tu = pps_source[source].assert_tu; + pi.clear_tu = pps_source[source].clear_tu; + pi.current_mode = pps_source[source].current_mode; + ret = copy_to_user(info, &pi, sizeof(struct pps_kinfo)); + if (ret) + ret = -EFAULT; + +sys_time_pps_fetch_exit: + mutex_unlock(&pps_mutex); + + return ret; +} + +/* + * Module staff + */ + +static void __exit pps_exit(void) +{ + pps_sysfs_unregister(); + + pr_info("LinuxPPS API ver. %d removed\n", PPS_API_VERS); +} + +static int __init pps_init(void) +{ + int i, ret; + + /* Init pps_source info */ + for (i = 0; i < PPS_MAX_SOURCES; i++) + memset(&pps_source[i], 0, sizeof(struct pps_s)); + + /* Register to sysfs */ + ret = pps_sysfs_register(); + if (ret < 0) { + printk(KERN_ERR "unable to register sysfs\n"); + return ret; + } + + pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS); + pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti " + "<giometti@linux.it>\n", PPS_VERSION); + + return 0; +} + +subsys_initcall(pps_init); +module_exit(pps_exit); + +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); +MODULE_LICENSE("GPL"); diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c new file mode 100644 index 0000000..e52dd8e --- /dev/null +++ b/drivers/pps/sysfs.c @@ -0,0 +1,217 @@ +/* + * sysfs.c -- sysfs support + * + * + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/string.h> + +#include <linux/pps.h> + +/* + * Private functions + */ + +static ssize_t pps_show_assert(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->assert_tu.sec, dev->assert_tu.nsec, + dev->assert_sequence); +} + +static ssize_t pps_show_clear(struct class_device *cdev, char *buf) +{ + struct pps_s *dev = class_get_devdata(cdev); + + return sprintf(buf, "%lld.%09d#%d\n", + dev->clear_tu.sec, dev->clear_tu.nsec, + dev->clear_sequence); +} + +static ssize_t pps_show_mode(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%4x\n", info->mode); +} + +static ssize_t pps_show_echo(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%d\n", !!info->echo); +} + +static ssize_t pps_show_name(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->name); +} + +static ssize_t pps_show_path(struct class_device *cdev, char *buf) +{ + struct pps_source_info_s *info = to_pps_info(cdev); + + return sprintf(buf, "%s\n", info->path); +} + +/* + * Files definitions + */ + +#define DECLARE_INFO_ATTR(_name, _mode, _show, _store) \ +{ \ + .attr = { \ + .name = __stringify(_name), \ + .mode = _mode, \ + .owner = THIS_MODULE, \ + }, \ + .show = _show, \ + .store = _store, \ +} + +static struct class_device_attribute pps_class_device_attributes[] = { + DECLARE_INFO_ATTR(assert, 0444, pps_show_assert, NULL), + DECLARE_INFO_ATTR(clear, 0444, pps_show_clear, NULL), + DECLARE_INFO_ATTR(mode, 0444, pps_show_mode, NULL), + DECLARE_INFO_ATTR(echo, 0444, pps_show_echo, NULL), + DECLARE_INFO_ATTR(name, 0444, pps_show_name, NULL), + DECLARE_INFO_ATTR(path, 0444, pps_show_path, NULL), +}; + +/* + * Class definitions + */ + +static void pps_class_release(struct class_device *cdev) +{ + /* Nop??? */ +} + +static struct class pps_class = { + .name = "pps", + .release = pps_class_release, +}; + +/* + * Public functions + */ + +void pps_sysfs_remove_source_entry(struct pps_source_info_s *info) +{ + int i; + + /* Sanity checks */ + if (info == NULL) + return; + + /* Delete info files */ + if (info->mode&PPS_CAPTUREASSERT) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[0]); + + if (info->mode&PPS_CAPTURECLEAR) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[1]); + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + /* Deregister the pps class */ + class_device_unregister(&info->class_dev); +} + +int pps_sysfs_create_source_entry(struct pps_source_info_s *info, int id) +{ + char buf[32]; + int i, ret; + + /* Sanity checks */ + if (info == NULL || id >= PPS_MAX_SOURCES) + return -EINVAL; + + /* Create dir class device name */ + sprintf(buf, "%.02d", id); + + /* Setup the class struct */ + memset(&info->class_dev, 0, sizeof(struct class_device)); + info->class_dev.class = &pps_class; + strlcpy(info->class_dev.class_id, buf, KOBJ_NAME_LEN); + class_set_devdata(&info->class_dev, &pps_source[id]); + + /* Register the new class */ + ret = class_device_register(&info->class_dev); + if (unlikely(ret)) + goto error_class_device_register; + + /* Create info files */ + + /* Create file "assert" and "clear" according to source capability */ + if (info->mode & PPS_CAPTUREASSERT) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[0]); + i = 0; + if (unlikely(ret)) + goto error_class_device_create_file; + } + if (info->mode & PPS_CAPTURECLEAR) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[1]); + i = 1; + if (unlikely(ret)) + goto error_class_device_create_file; + } + + for (i = 2; i < ARRAY_SIZE(pps_class_device_attributes); i++) { + ret = class_device_create_file(&info->class_dev, + &pps_class_device_attributes[i]); + if (unlikely(ret)) + goto error_class_device_create_file; + } + + return 0; + +error_class_device_create_file: + while (--i >= 0) + class_device_remove_file(&info->class_dev, + &pps_class_device_attributes[i]); + + class_device_unregister(&info->class_dev); + /* Here the release() method was already called */ + +error_class_device_register: + + return ret; +} + +void pps_sysfs_unregister(void) +{ + class_unregister(&pps_class); +} + +int pps_sysfs_register(void) +{ + return class_register(&pps_class); +} diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c index c84dab0..0c9a307 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c @@ -2101,6 +2101,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios, up->ier |= UART_IER_MSI; if (up->capabilities & UART_CAP_UUE) up->ier |= UART_IER_UUE | UART_IER_RTOIE; + if (up->port.flags & UPF_HARDPPS_CD) + up->ier |= UART_IER_MSI; /* enable interrupts */ serial_out(up, UART_IER, up->ier); diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index 326020f..cc5b4fc 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -33,6 +33,7 @@ #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/pps.h> #include <asm/irq.h> #include <asm/uaccess.h> @@ -633,6 +634,53 @@ static int uart_get_info(struct uart_state *state, return 0; } +#ifdef CONFIG_PPS_CLIENT_UART + +static int +uart_register_pps_port(struct uart_state *state, struct uart_port *port) +{ + struct tty_driver *drv = port->info->tty->driver; + int ret; + + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d", + drv->driver_name, port->line); + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", + drv->name, port->line); + + state->pps_info.mode = PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ + PPS_CANWAIT | PPS_TSFMT_TSPEC; + + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \ + PPS_OFFSETASSERT | PPS_OFFSETCLEAR, + -1 /* PPS ID is up to the system */); + if (ret < 0) { + dev_err(port->dev, "cannot register PPS source \"%s\"\n", + state->pps_info.path); + return ret; + } + port->pps_source = ret; + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n", + port->pps_source, state->pps_info.path); + + return 0; +} + +static void +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port) +{ + pps_unregister_source(&state->pps_info); + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n", + port->pps_source, state->pps_info.path); +} + +#else + +#define uart_register_pps_port(state, port) do { } while (0) +#define uart_unregister_pps_port(state, port) do { } while (0) + +#endif /* CONFIG_PPS_CLIENT_UART */ + static int uart_set_info(struct uart_state *state, struct serial_struct __user *newinfo) { @@ -807,11 +855,19 @@ static int uart_set_info(struct uart_state *state, (port->flags & UPF_LOW_LATENCY) ? 1 : 0; check_and_exit: + /* PPS support enabled/disabled? */ + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) { + if (new_flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + else + uart_unregister_pps_port(state, port); + } + retval = 0; if (port->type == PORT_UNKNOWN) goto exit; if (state->info->flags & UIF_INITIALIZED) { - if (((old_flags ^ port->flags) & UPF_SPD_MASK) || + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) || old_custom_divisor != port->custom_divisor) { /* * If they're setting up a custom divisor or speed, @@ -2100,6 +2156,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, port->ops->config_port(port, flags); } + /* + * Add the PPS support for the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_register_pps_port(state, port); + if (port->type != PORT_UNKNOWN) { unsigned long flags; @@ -2349,6 +2411,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) mutex_unlock(&state->mutex); /* + * Remove PPS support from the current port. + */ + if (port->flags & UPF_HARDPPS_CD) + uart_unregister_pps_port(state, port); + + /* * Remove the devices from the tty layer */ tty_unregister_device(drv->tty_driver, port->line); diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h index e84ace1..36746dc 100644 --- a/include/asm-i386/unistd.h +++ b/include/asm-i386/unistd.h @@ -329,10 +329,15 @@ #define __NR_signalfd 321 #define __NR_timerfd 322 #define __NR_eventfd 323 +#define __NR_time_pps_cmd 324 +#define __NR_time_pps_getparams 325 +#define __NR_time_pps_setparams 326 +#define __NR_time_pps_getcap 327 +#define __NR_time_pps_fetch 328 #ifdef __KERNEL__ -#define NR_syscalls 324 +#define NR_syscalls 329 #define __ARCH_WANT_IPC_PARSE_VERSION #define __ARCH_WANT_OLD_READDIR diff --git a/include/linux/Kbuild b/include/linux/Kbuild index f317c27..a10d20a 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -293,6 +293,7 @@ unifdef-y += pmu.h unifdef-y += poll.h unifdef-y += ppp_defs.h unifdef-y += ppp-comp.h +unifdef-y += pps.h unifdef-y += ptrace.h unifdef-y += qnx4_fs.h unifdef-y += quota.h diff --git a/include/linux/parport.h b/include/linux/parport.h index 9cdd694..0ecce1f 100644 --- a/include/linux/parport.h +++ b/include/linux/parport.h @@ -100,6 +100,7 @@ typedef enum { #include <linux/proc_fs.h> #include <linux/spinlock.h> #include <linux/wait.h> +#include <linux/pps.h> #include <asm/system.h> #include <asm/ptrace.h> #include <asm/semaphore.h> @@ -327,6 +328,11 @@ struct parport { struct list_head full_list; struct parport *slaves[3]; + +#ifdef CONFIG_PPS_CLIENT_LP + struct pps_source_info_s pps_info; + int pps_source; /* PPS source ID */ +#endif }; #define DEFAULT_SPIN_TIME 500 /* us */ @@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode); /* Lowlevel drivers _can_ call this support function to handle irqs. */ static __inline__ void parport_generic_irq(int irq, struct parport *port) { +#ifdef CONFIG_PPS_CLIENT_LP + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); +#endif + parport_ieee1284_interrupt (irq, port); read_lock(&port->cad_lock); if (port->cad && port->cad->irq_func) diff --git a/include/linux/pps.h b/include/linux/pps.h new file mode 100644 index 0000000..6eca3ea --- /dev/null +++ b/include/linux/pps.h @@ -0,0 +1,206 @@ +/* + * pps.h -- PPS API kernel header. + * + * + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifndef _PPS_H_ +#define _PPS_H_ + +/* Implementation note: the logical states ``assert'' and ``clear'' + * are implemented in terms of the chip register, i.e. ``assert'' + * means the bit is set. */ + +/* + * 3.2 New data structures + */ + +#ifndef __KERNEL__ +#include <linux/types.h> +#include <sys/time.h> +#else +#include <linux/time.h> +#endif + +#define PPS_API_VERS_2 2 /* LinuxPPS proposal, dated 2006-05 */ +#define PPS_API_VERS PPS_API_VERS_2 +#define LINUXPSS_API 1 /* mark LinuxPPS API */ + +#define PPS_MAX_NAME_LEN 32 + +/* 32-bit vs. 64-bit compatibility. + * + * 0n i386, the alignment of a uint64_t is only 4 bytes, while on most other + * architectures it's 8 bytes. On i386, there will be no padding between the + * two consecutive 'struct pps_ktime' members of struct pps_kinfo and struct + * pps_kparams. But on most platforms there will be padding to ensure correct + * alignment. + * + * The simple fix is probably to add an explicit padding. + * [David Woodhouse] + */ +struct pps_ktime { + __u64 sec; + __u32 nsec; + __u32 padding; +}; + +struct pps_kinfo { + __u32 assert_sequence; /* seq. num. of assert event */ + __u32 clear_sequence; /* seq. num. of clear event */ + struct pps_ktime assert_tu; /* time of assert event */ + struct pps_ktime clear_tu; /* time of clear event */ + int current_mode; /* current mode bits */ +}; + +struct pps_kparams { + int api_version; /* API version # */ + int mode; /* mode bits */ + struct pps_ktime assert_off_tu; /* offset compensation for assert */ + struct pps_ktime clear_off_tu; /* offset compensation for clear */ +}; + +/* + * 3.3 Mode bit definitions + */ + +/* Device/implementation parameters */ +#define PPS_CAPTUREASSERT 0x01 /* capture assert events */ +#define PPS_CAPTURECLEAR 0x02 /* capture clear events */ +#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */ + +#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */ +#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */ + +#define PPS_CANWAIT 0x100 /* can we wait for an event? */ +#define PPS_CANPOLL 0x200 /* bit reserved for future use */ + +/* Kernel actions */ +#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */ +#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */ + +/* Timestamp formats */ +#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */ +#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */ + +/* + * 3.4.4 New functions: disciplining the kernel timebase + */ + +/* Kernel consumers */ +#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */ +#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to + use a phase-locked loop */ +#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to + use a frequency-locked loop */ +/* + * Here begins the implementation-specific part! + */ + +#include <linux/ioctl.h> + +struct pps_source_data_s { + int source; + char name[PPS_MAX_NAME_LEN]; + char path[PPS_MAX_NAME_LEN]; +}; + +#define PPS_CMD_FIND_SRC _IOWR('P', 1, struct pps_source_data *) +#define PPS_CMD_FIND_PATH _IOWR('P', 2, struct pps_source_data *) + +#ifdef __KERNEL__ + +#include <linux/device.h> + +/* + * Misc macros + */ + +#define PPS_VERSION "4.0.0-rc4" + +/* + * Global defines + */ + +#define PPS_MAX_SOURCES 16 + +/* The specific PPS source info */ +struct pps_source_info_s { + char name[PPS_MAX_NAME_LEN]; /* simbolic name */ + char path[PPS_MAX_NAME_LEN]; /* path of connected device */ + int mode; /* PPS's allowed mode */ + + void (*echo)(int source, int event, void *data); /* PPS echo function */ + + /* sysfs section */ + struct class_device class_dev; +}; + +/* The main struct */ +struct pps_s { + struct pps_source_info_s *info; /* PSS source info */ + + struct pps_kparams params; /* PPS's current params */ + + __u32 assert_sequence; /* PPS' assert event seq # */ + __u32 clear_sequence; /* PPS' clear event seq # */ + struct pps_ktime assert_tu; + struct pps_ktime clear_tu; + int current_mode; /* PPS mode at event time */ + + int go; /* PPS event is arrived? */ + wait_queue_head_t queue; /* PPS event queue */ +}; + +/* + * Global variables + */ + +extern struct pps_s pps_source[PPS_MAX_SOURCES]; +extern struct mutex pps_mutex; + +/* + * Global functions + */ + +static inline int pps_is_allocated(int source) +{ + return pps_source[source].info != NULL; +} + +#define to_pps_info(obj) container_of((obj), struct pps_source_info_s, class_dev) + +/* + * Exported functions + */ + +extern int pps_register_source(struct pps_source_info_s *info, + int default_params, int try_id); +extern void pps_unregister_source(struct pps_source_info_s *info); +extern void pps_event(int source, int event, void *data); + +extern int pps_sysfs_create_source_entry(struct pps_source_info_s *info, + int id); +extern void pps_sysfs_remove_source_entry(struct pps_source_info_s *info); +extern int pps_sysfs_register(void); +extern void pps_sysfs_unregister(void); + +#endif /* __KERNEL__ */ + +#endif /* _PPS_H_ */ diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h index 7f2c99d..01f3459 100644 --- a/include/linux/serial_core.h +++ b/include/linux/serial_core.h @@ -153,6 +153,7 @@ #include <linux/tty.h> #include <linux/mutex.h> #include <linux/sysrq.h> +#include <linux/pps.h> struct uart_port; struct uart_info; @@ -232,6 +233,9 @@ struct uart_port { unsigned char regshift; /* reg offset shift */ unsigned char iotype; /* io access style */ unsigned char unused1; +#ifdef CONFIG_PPS_CLIENT_UART + int pps_source; /* PPS source ID */ +#endif #define UPIO_PORT (0) #define UPIO_HUB6 (1) @@ -276,7 +280,8 @@ struct uart_port { #define UPF_IOREMAP ((__force upf_t) (1 << 31)) #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff)) -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY)) +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\ + |UPF_HARDPPS_CD)) unsigned int mctrl; /* current modem ctrl settings */ unsigned int timeout; /* character-based timeout */ @@ -308,6 +313,10 @@ struct uart_state { struct uart_info *info; struct uart_port *port; +#ifdef CONFIG_PPS_CLIENT_UART + struct pps_source_info_s pps_info; +#endif + struct mutex mutex; }; @@ -472,13 +481,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status) { struct uart_info *info = port->info; - port->icount.dcd++; - -#ifdef CONFIG_HARD_PPS - if ((port->flags & UPF_HARDPPS_CD) && status) - hardpps(); +#ifdef CONFIG_PPS_CLIENT_UART + if (port->flags & UPF_HARDPPS_CD) { + if (status) { + pps_event(port->pps_source, PPS_CAPTUREASSERT, port); + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n", + jiffies, port->pps_source); + } else { + pps_event(port->pps_source, PPS_CAPTURECLEAR, port); + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n", + jiffies, port->pps_source); + } + } #endif + port->icount.dcd++; + if (info->flags & UIF_CHECK_CD) { if (status) wake_up_interruptible(&info->open_wait); diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 83d0ec1..bfc8899 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -65,6 +65,7 @@ struct getcpu_cache; #include <asm/signal.h> #include <linux/quota.h> #include <linux/key.h> +#include <linux/pps.h> asmlinkage long sys_time(time_t __user *tloc); asmlinkage long sys_stime(time_t __user *tptr); @@ -611,6 +612,15 @@ asmlinkage long sys_timerfd(int ufd, int clockid, int flags, const struct itimerspec __user *utmr); asmlinkage long sys_eventfd(unsigned int count); +asmlinkage long sys_time_pps_cmd(int cmd, void __user *arg); +asmlinkage long sys_time_pps_getparams(int source, + struct pps_kparams __user *params); +asmlinkage long sys_time_pps_setparams(int source, + const struct pps_kparams __user *params); +asmlinkage long sys_time_pps_getcap(int source, int __user *mode); +asmlinkage long sys_time_pps_fetch(int source, struct pps_kinfo __user *info, + const struct pps_ktime __user *timeout); + int kernel_execve(const char *filename, char *const argv[], char *const envp[]); #endif diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 7e11e2c..e0fccc2 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -148,3 +148,10 @@ cond_syscall(sys_timerfd); cond_syscall(compat_sys_signalfd); cond_syscall(compat_sys_timerfd); cond_syscall(sys_eventfd); + +/* PPS dependent */ +cond_syscall(sys_time_pps_find); +cond_syscall(sys_time_pps_getparams); +cond_syscall(sys_time_pps_setparams); +cond_syscall(sys_time_pps_getcap); +cond_syscall(sys_time_pps_fetch); ^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti @ 2007-07-27 19:08 ` Chris Friesen 2007-07-27 19:28 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Chris Friesen @ 2007-07-27 19:08 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton Rodolfo Giometti wrote: > The pps_event() is now protected by a spinlock against > pps_register_source() and pps_unregister_source()... Locks protect data, not code. It may make more sense to identify the specific data being protected by the spinlock. Chris ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 19:08 ` Chris Friesen @ 2007-07-27 19:28 ` Rodolfo Giometti 2007-07-27 19:40 ` Chris Friesen 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-27 19:28 UTC (permalink / raw) To: Chris Friesen; +Cc: David Woodhouse, linux-kernel, Andrew Morton On Fri, Jul 27, 2007 at 01:08:58PM -0600, Chris Friesen wrote: > Rodolfo Giometti wrote: > >> The pps_event() is now protected by a spinlock against >> pps_register_source() and pps_unregister_source()... > > Locks protect data, not code. It may make more sense to identify the > specific data being protected by the spinlock. What do you mean? Did you find an error into my patch? :-o Functions pps_event() and pps_register_source()/pps_unregister_source() take accesso to shared data, that's why I used spinlocks. Thanks, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 19:28 ` Rodolfo Giometti @ 2007-07-27 19:40 ` Chris Friesen 2007-07-27 19:45 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Chris Friesen @ 2007-07-27 19:40 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton Rodolfo Giometti wrote: > What do you mean? Did you find an error into my patch? :-o > > Functions pps_event() and > pps_register_source()/pps_unregister_source() take accesso to shared > data, that's why I used spinlocks. My point is that the lock should be used to protect specific data. Thus, it would be more correct to say, "spinlock foo is taken because pps_register_source() accesses variable bar". That way, if someone else wants to access "bar", they know that they need to take lock "foo". Chris ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 19:40 ` Chris Friesen @ 2007-07-27 19:45 ` Rodolfo Giometti 2007-07-27 20:47 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-27 19:45 UTC (permalink / raw) To: Chris Friesen; +Cc: David Woodhouse, linux-kernel, Andrew Morton On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote: > > My point is that the lock should be used to protect specific data. Thus, it > would be more correct to say, "spinlock foo is taken because > pps_register_source() accesses variable bar". > > That way, if someone else wants to access "bar", they know that they need > to take lock "foo". Ah, ok! I see. :) Thanks, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 19:45 ` Rodolfo Giometti @ 2007-07-27 20:47 ` Satyam Sharma 2007-07-27 23:41 ` Satyam Sharma 2007-07-29 9:17 ` Rodolfo Giometti 0 siblings, 2 replies; 43+ messages in thread From: Satyam Sharma @ 2007-07-27 20:47 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi Rodolfo, On 7/28/07, Rodolfo Giometti <giometti@enneenne.com> wrote: > On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote: > > > > My point is that the lock should be used to protect specific data. Thus, it > > would be more correct to say, "spinlock foo is taken because > > pps_register_source() accesses variable bar". > > > > That way, if someone else wants to access "bar", they know that they need > > to take lock "foo". > > Ah, ok! I see. :) I only glanced through the code, so could be wrong, but I noticed that the only global / shared data you have in there is a global "pps_source" array of pps_s structs. That's accessed / modified from the various syscalls introduced in the API exported to userspace, as well as the register/unregister/pps_event API exported to in-kernel client subsystems, yes? So it looks like you need to introduce proper locking for it, simply type-qualifying it as "volatile" is not enough. However, I think you've introduced two locks for it. The syscalls (that run in process context, obviously) seem to use a pps_mutex and pps_event() seems to be using the pps_lock spinlock (because that gets executed from interrupt context) -- and from the looks of it, the register/unregister functions are using /both/ the mutex and spinlock (!) This isn't quite right, (in fact there's nothing to protect pps_event from racing against a syscall), so you should use *only* the spinlock for synchronization -- the spin_lock_irqsave/restore() variants, in fact. [ Also, have you considered making pps_source a list and not an array? It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc kind of gymnastics in there, and you _can_ return a pointer to the corresponding pps source struct from the register() function to the in-kernel users, so that way you get to retain the O(1) access to the corresponding source when a client calls into pps_event(), similar to how you're using the array index presently. ] I also noticed code like (from pps_event): + /* Try to grab the lock, if not we prefere loose the event... */ + if (!spin_trylock(&pps_lock)) + return; which looks worrisome and unnecessary. That spinlock looks to be of fine enough granularity to me, do you think there'd be any contention on it? I /think/ you can simply make that a spin_lock(). Overall the code looks simple / straightforward enough to me (except for the parport / uart stuff that I have no clue about), and I'll also read up on the relevant RFC for this and would hopefully try and give you a more meaningful review over the weekend. Thanks, Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 20:47 ` Satyam Sharma @ 2007-07-27 23:41 ` Satyam Sharma 2007-07-29 9:50 ` Rodolfo Giometti ` (2 more replies) 2007-07-29 9:17 ` Rodolfo Giometti 1 sibling, 3 replies; 43+ messages in thread From: Satyam Sharma @ 2007-07-27 23:41 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi, On 7/28/07, Satyam Sharma <satyam.sharma@gmail.com> wrote: > Hi Rodolfo, > > On 7/28/07, Rodolfo Giometti <giometti@enneenne.com> wrote: > > On Fri, Jul 27, 2007 at 01:40:14PM -0600, Chris Friesen wrote: > > > > > > My point is that the lock should be used to protect specific data. Thus, it > > > would be more correct to say, "spinlock foo is taken because > > > pps_register_source() accesses variable bar". > > > > > > That way, if someone else wants to access "bar", they know that they need > > > to take lock "foo". > > > > Ah, ok! I see. :) > > I only glanced through the code, so could be wrong, but I noticed that > the only global / shared data you have in there is a global "pps_source" > array of pps_s structs. That's accessed / modified from the various > syscalls introduced in the API exported to userspace, as well as the > register/unregister/pps_event API exported to in-kernel client subsystems, > yes? So it looks like you need to introduce proper locking for it, simply > type-qualifying it as "volatile" is not enough. > > However, I think you've introduced two locks for it. The syscalls (that > run in process context, obviously) seem to use a pps_mutex and > pps_event() seems to be using the pps_lock spinlock (because that > gets executed from interrupt context) -- and from the looks of it, the > register/unregister functions are using /both/ the mutex and spinlock (!) > > This isn't quite right, (in fact there's nothing to protect pps_event from > racing against a syscall), so you should use *only* the spinlock for > synchronization -- the spin_lock_irqsave/restore() variants, in fact. Take the race between the time_pps_setparams() syscall and a concurrent pps_event() from an interrupt for instance. From sys_time_pps_setparams, the parameters for an existing source are not modified / set atomically, which means a pps_event() called on the same source in between will see invalid parameters ... and bad things will happen. > [ Also, have you considered making pps_source a list and not an array? > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc > kind of gymnastics in there, and you _can_ return a pointer to the > corresponding pps source struct from the register() function to the in-kernel > users, so that way you get to retain the O(1) access to the corresponding > source when a client calls into pps_event(), similar to how you're using the > array index presently. ] I think the above would be sane and safe -- your driver has pretty simple lifetime rules, and "sources" are only created / destroyed from within kernel, as and when clients call pps_register_source() and pps_unregister_source(). So pps_event() can be called on a given source only between the corresponding register() and unregister() -- which means register() can return us a reference/pointer on the source after allocating / adding it to the list (instead of the fixed array index as it presently is), which remains valid for the entire duration of the source, till unregister() is called, after which we can't be calling pps_event() on the same source anyway. > I also noticed code like (from pps_event): > > + /* Try to grab the lock, if not we prefere loose the event... */ > + if (!spin_trylock(&pps_lock)) > + return; > > which looks worrisome and unnecessary. That spinlock looks to be of > fine enough granularity to me, do you think there'd be any contention > on it? I /think/ you can simply make that a spin_lock(). > > Overall the code looks simple / straightforward enough to me (except for > the parport / uart stuff that I have no clue about), and I'll also read up on > the relevant RFC for this and would hopefully try and give you a more > meaningful review over the weekend. Ok, I've looked through (most of) the RFC and code now, and am only commenting on a design-level for now. Anyway, I didn't like the way you've significantly drifted from the RFC in several ways: 1. The RFC mandates no such userspace interface / syscall as the time_pps_cmd() that you've implemented -- it looks, smells, and feels like an ioctl, in fact that's what it is for practical purposes. I'm confused as to why didn't you just go ahead and implement the special-file-and- file-descriptor based approach as advocated / mandated there. [ You've implemented the (optional, as per RFC) time_pps_findsource operation in the kernel using the above "pseudo-ioctl", but that wasn't necessary -- as the RFC itself illustrates, it's something that can easily be done (in fact should be done) completely in userspace itself. ] 2. If you fix the above two issues, you'll notice that you don't need to short-circuit the (RFC-mandated) time_pps_create/destroy(handle) syscalls in the userspace header/library anymore, as you presently are. Here's how I'd go about desiging/implementing this: * At the time of pps_register_source() -- called by an in-kernel client subsystem that creates a PPS source -- allocate a pps source, generate an identifier for it, instantiate a special file -- the RFC does not mention whether a char or block device, but char device (I noticed an example in the RFC where they've used /dev/ppsXX as a possible path) would be proper for this. Finally add it to the list of sources. This returns a reference/pointer on that source back to the in-kernel client, which then passes *that* to pps_event(), similar to how you're presently using the array index. [ The way you've passed the path of the parport/uart device itself (/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source() in pps_info.path doesn't quite look right to me. Note that the userspace is expected to open(2) the special file corresponding to the *PPS* source, as instantiated from the above code, and not the /dev/xyz special file of the *physical* port through which a pulse-generating device may be connected to the PC. ] * Userspace will open(2) the special file, and get an fd. Then calls the time_pps_create(fd, &handle) syscall -- kernel will find the pps source that matches that passed fd from the list of sources, and instantiates a "handle" associated with that source and returns that back to userspace. The rest would happen as usual / as you've currently implemented. I /think/ the RFC does envision such an implementation, so it helps us comply with that standard, and would also get rid of a lot of kludgy "findpath" and "findsource" stuff that we otherwise have to do in-kernel and userspace, as we're presently doing in the patch. [ BTW, it would be nice if you submit this stuff as a patchset that brings in functionality over a series of multiple patches -- the sysfs interface bits can be introduced in a different patch from the syscalls, which can be introduced in a different patch from the kernel-side API, etc ... that helps a code-level review. ] Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 23:41 ` Satyam Sharma @ 2007-07-29 9:50 ` Rodolfo Giometti 2007-07-30 5:03 ` Satyam Sharma 2007-07-29 9:57 ` Rodolfo Giometti 2007-07-29 10:00 ` Rodolfo Giometti 2 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-29 9:50 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote: > > Take the race between the time_pps_setparams() syscall and a concurrent > pps_event() from an interrupt for instance. From sys_time_pps_setparams, > the parameters for an existing source are not modified / set atomically, > which means a pps_event() called on the same source in between will see > invalid parameters ... and bad things will happen. I are right. I'll add spinlocks. :) > > [ Also, have you considered making pps_source a list and not an array? > > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc > > kind of gymnastics in there, and you _can_ return a pointer to the > > corresponding pps source struct from the register() function to the in-kernel > > users, so that way you get to retain the O(1) access to the corresponding > > source when a client calls into pps_event(), similar to how you're using the > > array index presently. ] > > I think the above would be sane and safe -- your driver has pretty simple > lifetime rules, and "sources" are only created / destroyed from within kernel, > as and when clients call pps_register_source() and pps_unregister_source(). > So pps_event() can be called on a given source only between the > corresponding register() and unregister() -- which means register() can > return us a reference/pointer on the source after allocating / adding it to > the list (instead of the fixed array index as it presently is), which remains > valid for the entire duration of the source, till unregister() is called, after > which we can't be calling pps_event() on the same source anyway. Ok. I see. I'll study the problem but I think this is can be done later, now I think is better having a working code. :) > Ok, I've looked through (most of) the RFC and code now, and am only > commenting on a design-level for now. Anyway, I didn't like the way > you've significantly drifted from the RFC in several ways: > > 1. The RFC mandates no such userspace interface / syscall as the > time_pps_cmd() that you've implemented -- it looks, smells, and feels > like an ioctl, in fact that's what it is for practical purposes. I'm confused > as to why didn't you just go ahead and implement the special-file-and- > file-descriptor based approach as advocated / mandated there. This is because is not always true that a PPS source is connected with a char (or other) device. People whose designed RFC didn't think about systems where the PPS signal is connected with a CPU's GPIO and the O.S. doesn't provide any char device to refere with! In the common desktop PCs the GPS antenna is connected with the serial line and the PPS source is attached to the serial CD, but in the embedded systems this is _not_ true. GPS antennae may still be connected with serial line but the PPS signal is usually connected with a GPIO pin. In this scenario you cannot use the serial file descriptor to manage the PPS signal since it cannot goes to the serial port. > [ You've implemented the (optional, as per RFC) time_pps_findsource > operation in the kernel using the above "pseudo-ioctl", but that wasn't > necessary -- as the RFC itself illustrates, it's something that can easily > be done (in fact should be done) completely in userspace itself. ] I used pseudo-ioctl interface since it allows me to easily extend PPS support with special, and uncommon, commands. > 2. If you fix the above two issues, you'll notice that you don't need to > short-circuit the (RFC-mandated) time_pps_create/destroy(handle) > syscalls in the userspace header/library anymore, as you presently are. This is just the reason why I added those functions. :) > Here's how I'd go about desiging/implementing this: > > * At the time of pps_register_source() -- called by an in-kernel client > subsystem that creates a PPS source -- allocate a pps source, generate > an identifier for it, instantiate a special file -- the RFC does not mention > whether a char or block device, but char device (I noticed an example > in the RFC where they've used /dev/ppsXX as a possible path) would be > proper for this. Finally add it to the list of sources. This returns a > reference/pointer on that source back to the in-kernel client, which then > passes *that* to pps_event(), similar to how you're presently using the > array index. If your GPS antenna is connected with a CPU's GPIO you have _no_ in-kernel client subsystem that creates a PPS source. > [ The way you've passed the path of the parport/uart device itself > (/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source() > in pps_info.path doesn't quite look right to me. Note that the userspace is > expected to open(2) the special file corresponding to the *PPS* source, > as instantiated from the above code, and not the /dev/xyz special file of > the *physical* port through which a pulse-generating device may be > connected to the PC. ] As above, if your GPS antenna is connected with a CPU's GPIO you have _no_ device to open at all, that's why you need at least a function like pps_findsource(). Note that in this case the pps_info.path is void. Please, see the special client drivers/pps/clients/ktimer.c, it emulates the case where you have no /dev/XXX to open(2). If your modifications resolve the problems to manage the ktimer client you are going in the right direction. > * Userspace will open(2) the special file, and get an fd. Then calls the > time_pps_create(fd, &handle) syscall -- kernel will find the pps source > that matches that passed fd from the list of sources, and instantiates a > "handle" associated with that source and returns that back to userspace. Ditto. > The rest would happen as usual / as you've currently implemented. > > I /think/ the RFC does envision such an implementation, so it helps us > comply with that standard, and would also get rid of a lot of kludgy > "findpath" and "findsource" stuff that we otherwise have to do in-kernel > and userspace, as we're presently doing in the patch. Unluckily the RFC does _not_ take into account PPS sources connected with CPU's GPIO... in this case, in fact, you have _no_ char/block device to open(). > [ BTW, it would be nice if you submit this stuff as a patchset that brings > in functionality over a series of multiple patches -- the sysfs interface bits > can be introduced in a different patch from the syscalls, which can be > introduced in a different patch from the kernel-side API, etc ... that helps > a code-level review. ] Ok, I see, but I think this should be done when everithing is ok. I think after fixing locking issue I can do it, can't I? Thanks, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-29 9:50 ` Rodolfo Giometti @ 2007-07-30 5:03 ` Satyam Sharma 2007-07-30 8:51 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 5:03 UTC (permalink / raw) To: Rodolfo Giometti Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi, On Sun, 29 Jul 2007, Rodolfo Giometti wrote: > On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote: > > > > [ Also, have you considered making pps_source a list and not an array? > > > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc > > > kind of gymnastics in there, and you _can_ return a pointer to the > > > corresponding pps source struct from the register() function to the in-kernel > > > users, so that way you get to retain the O(1) access to the corresponding > > > source when a client calls into pps_event(), similar to how you're using the > > > array index presently. ] > > > > I think the above would be sane and safe -- your driver has pretty simple > > lifetime rules, and "sources" are only created / destroyed from within kernel, > > as and when clients call pps_register_source() and pps_unregister_source(). > > So pps_event() can be called on a given source only between the > > corresponding register() and unregister() -- which means register() can > > return us a reference/pointer on the source after allocating / adding it to > > the list (instead of the fixed array index as it presently is), which remains > > valid for the entire duration of the source, till unregister() is called, after > > which we can't be calling pps_event() on the same source anyway. > > Ok. I see. I'll study the problem but I think this is can be done > later, now I think is better having a working code. :) Fair enough, but I think the code could become a trifle simpler/easier after the conversion, so probably greater chances of getting merged :-) > > Ok, I've looked through (most of) the RFC and code now, and am only > > commenting on a design-level for now. Anyway, I didn't like the way > > you've significantly drifted from the RFC in several ways: > > > > 1. The RFC mandates no such userspace interface / syscall as the > > time_pps_cmd() that you've implemented -- it looks, smells, and feels > > like an ioctl, in fact that's what it is for practical purposes. I'm confused > > as to why didn't you just go ahead and implement the special-file-and- > > file-descriptor based approach as advocated / mandated there. > > This is because is not always true that a PPS source is connected with > a char (or other) device. But that's alright -- see, as I said, you're confusing between the "special device" that represents the *PPS source* itself, with the port or device that it uses to *physically* connect to the PC. In the RFC, when they say that the userspace app must open(2) the PPS source (as they have illustrated in the example too), they mean that it open(2)'s the special device/file associated with the PPS source, and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected through physically. So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course, no such special device exists on a Linux box already, but that's fine and obvious! *You* are supposed to create / instantiate that when a pps_register_source() is done from some in-kernel subsystem. > People whose designed RFC didn't think about > systems where the PPS signal is connected with a CPU's GPIO and the > O.S. doesn't provide any char device to refere with! As I said, it's not the char device for the physical interface itself being discussed there. That could be parport, uart, some arbit GPIO pin whatever. But whenever the corresponding kernel subsystem does a register_source(), you could create the /dev/ppsXXX device ... > In the common desktop PCs the GPS antenna is connected with the serial > line and the PPS source is attached to the serial CD, but in the > embedded systems this is _not_ true. GPS antennae may still be > connected with serial line but the PPS signal is usually connected > with a GPIO pin. > > In this scenario you cannot use the serial file descriptor to manage > the PPS signal since it cannot goes to the serial port. See above. > > [ You've implemented the (optional, as per RFC) time_pps_findsource > > operation in the kernel using the above "pseudo-ioctl", but that wasn't > > necessary -- as the RFC itself illustrates, it's something that can easily > > be done (in fact should be done) completely in userspace itself. ] > > I used pseudo-ioctl interface since it allows me to easily extend PPS > support with special, and uncommon, commands. Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see how you can get this merged, really :-) > > * At the time of pps_register_source() -- called by an in-kernel client > > subsystem that creates a PPS source -- allocate a pps source, generate > > an identifier for it, instantiate a special file -- the RFC does not mention > > whether a char or block device, but char device (I noticed an example > > in the RFC where they've used /dev/ppsXX as a possible path) would be > > proper for this. Finally add it to the list of sources. This returns a > > reference/pointer on that source back to the in-kernel client, which then > > passes *that* to pps_event(), similar to how you're presently using the > > array index. > > If your GPS antenna is connected with a CPU's GPIO you have _no_ > in-kernel client subsystem that creates a PPS source. See above. > > [ The way you've passed the path of the parport/uart device itself > > (/dev/lpXX or [/dev/%s%d, drv->name, port->line]) to register_source() > > in pps_info.path doesn't quite look right to me. Note that the userspace is > > expected to open(2) the special file corresponding to the *PPS* source, > > as instantiated from the above code, and not the /dev/xyz special file of > > the *physical* port through which a pulse-generating device may be > > connected to the PC. ] > > As above, if your GPS antenna is connected with a CPU's GPIO you have > _no_ device to open at all, that's why you need at least a function > like pps_findsource(). > > Note that in this case the pps_info.path is void. Please, see the > special client drivers/pps/clients/ktimer.c, it emulates the case > where you have no /dev/XXX to open(2). If your modifications resolve > the problems to manage the ktimer client you are going in the right > direction. Again, see above. > > I /think/ the RFC does envision such an implementation, so it helps us > > comply with that standard, and would also get rid of a lot of kludgy > > "findpath" and "findsource" stuff that we otherwise have to do in-kernel > > and userspace, as we're presently doing in the patch. > > Unluckily the RFC does _not_ take into account PPS sources connected > with CPU's GPIO... in this case, in fact, you have _no_ char/block > device to open(). And again, see above. Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 5:03 ` Satyam Sharma @ 2007-07-30 8:51 ` Rodolfo Giometti 2007-07-30 9:20 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-30 8:51 UTC (permalink / raw) To: Satyam Sharma Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote: > > Fair enough, but I think the code could become a trifle simpler/easier > after the conversion, so probably greater chances of getting merged :-) I see. I'll start thinging about it. > But that's alright -- see, as I said, you're confusing between the > "special device" that represents the *PPS source* itself, with the port > or device that it uses to *physically* connect to the PC. > > In the RFC, when they say that the userspace app must open(2) the PPS > source (as they have illustrated in the example too), they mean that > it open(2)'s the special device/file associated with the PPS source, > and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected > through physically. > > So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course, > no such special device exists on a Linux box already, but that's fine > and obvious! *You* are supposed to create / instantiate that when a > pps_register_source() is done from some in-kernel subsystem. So your are proposing to create a char device interface then using syscalls one? In this case how do you manage the case where your GPS antenna and PPS source are both connected with the serial port (i.e. /dev/ttyS0)? Currently the RFC says to you that you should open the serial port: fd = open("/dev/ttyS0", ...); and the passing its filedes to pps_time_create() in order to get the corresponding PPS source handler: pps_time_create(fd, &handler); As you propose you need _two_ open() and not just one... and even if you decide to open the /dev/ppsX inside the pps_time_create(), how do you recognise _which_ /dev/ppsX is connected with filedse "fd"? I quite sure that RFC is broken since it doesn't take in account that a PPS source maybe not connected with any cahr device at all. I tried to explain this problem to RFC's gurus but they never answered to me, so I decided to resolve the problem by myself. ;) > As I said, it's not the char device for the physical interface itself > being discussed there. That could be parport, uart, some arbit GPIO pin > whatever. But whenever the corresponding kernel subsystem does a > register_source(), you could create the /dev/ppsXXX device ... Ok, but in this case you still are _not_ RFC compliant (as showed above). You need that users give to you _two_ devices (the serial line and the PPS source), meanwhile, for the RFC, you just need one. So no differences from my solution from this point of view. > Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see > how you can get this merged, really :-) They are not-mandated-by-RFC since simply RFC _is broken_! :) I need them (or just one of them) in order to find a PPS source into the system. Just as you need the second device name in your solution with char devices. Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 8:51 ` Rodolfo Giometti @ 2007-07-30 9:20 ` Satyam Sharma 2007-08-01 22:14 ` Christopher Hoover 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 9:20 UTC (permalink / raw) To: Rodolfo Giometti Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote: > > > > Fair enough, but I think the code could become a trifle simpler/easier > > after the conversion, so probably greater chances of getting merged :-) > > I see. I'll start thinging about it. > > > But that's alright -- see, as I said, you're confusing between the > > "special device" that represents the *PPS source* itself, with the port > > or device that it uses to *physically* connect to the PC. > > > > In the RFC, when they say that the userspace app must open(2) the PPS > > source (as they have illustrated in the example too), they mean that > > it open(2)'s the special device/file associated with the PPS source, > > and *not* the /dev/lpXXX or /dev/ttySXXX that it might be connected > > through physically. > > > > So they mean something like /dev/pps0, /dev/pps1 etc instead. Of course, > > no such special device exists on a Linux box already, but that's fine > > and obvious! *You* are supposed to create / instantiate that when a > > pps_register_source() is done from some in-kernel subsystem. > > So your are proposing to create a char device interface then using > syscalls one? In this case how do you manage the case where your GPS > antenna and PPS source are both connected with the serial port > (i.e. /dev/ttyS0)? That's *precisely* what I just explained above! You create that special device at the time of pps_register_source()! > Currently the RFC says to you that you should open the serial port: > > fd = open("/dev/ttyS0", ...); No, it does *NOT*. All it says is: The time_pps_create() is used to convert an already-open UNIX file descriptor, for an appropriate special file, into a PPS handle. See? What I said is precisely the implementation the RFC envisages (and the only sane way to implement it too). And later, where it gives an example, it shows: fd = open(PPSfilename, O_RDWR, 0); What I'm saying is that the "PPSfilename", as is obvious from the name itself, is *not* a port such as lpXXX or ttySXXX, but an "appropriate special file" corresponding to a ... PPS source! Really, the RFC is quite clear and easy to read, I have no idea how to explain that more clearly ... > and the passing its filedes to pps_time_create() in order to get the > corresponding PPS source handler: > > pps_time_create(fd, &handler); Yes. > As you propose you need _two_ open() and not just one... No, why? > and even if > you decide to open the /dev/ppsX inside the pps_time_create(), how do > you recognise _which_ /dev/ppsX is connected with filedse "fd"? That's trivial to implement in the kernel code for the time_pps_create() syscall. > I quite sure that RFC is broken since it doesn't take in account that > a PPS source maybe not connected with any cahr device at all. I tried > to explain this problem to RFC's gurus but they never answered to me, > so I decided to resolve the problem by myself. ;) Nopes, the RFC is not broken at all. All this physical-connection-port device vs PPS-source-device confusion is just in your mind :-) > > As I said, it's not the char device for the physical interface itself > > being discussed there. That could be parport, uart, some arbit GPIO pin > > whatever. But whenever the corresponding kernel subsystem does a > > register_source(), you could create the /dev/ppsXXX device ... > > Ok, but in this case you still are _not_ RFC compliant (as showed > above). You need that users give to you _two_ devices (the serial line > and the PPS source), meanwhile, for the RFC, you just need one. So no > differences from my solution from this point of view. Yeah, so how am I not RFC compliant? Userspace will *only* open(2) the special char device of the *PPS source*, and have *nothing* to do with the device corresponding to the physical device/port it is connected through! > > Hmm, but that's a non-standard, not-mandated-by-RFC syscall. I don't see > > how you can get this merged, really :-) > > They are not-mandated-by-RFC since simply RFC _is broken_! :) It is not ... > I need them (or just one of them) in order to find a PPS source into > the system. Just as you need the second device name in your solution > with char devices. No, I don't need any "second device". I *only* need the "appropriate special file" as mentioned in the RFC. I don't give a *damn* for what *physical device/port* the source is actually connected through. I suggest you should read the RFC again ... Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 9:20 ` Satyam Sharma @ 2007-08-01 22:14 ` Christopher Hoover 2007-08-01 23:03 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Christopher Hoover @ 2007-08-01 22:14 UTC (permalink / raw) To: linux-kernel Satyam Sharma <satyam <at> infradead.org> writes: > On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > > > On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote: > > Currently the RFC says to you that you should open the serial port: > > > > fd = open("/dev/ttyS0", ...); > > No, it does *NOT*. All it says is: > > The time_pps_create() is used to convert an already-open UNIX file > descriptor, for an appropriate special file, into a PPS handle. > > See? What I said is precisely the implementation the RFC envisages > (and the only sane way to implement it too). If we were totally rigurous about representing each device as a device node, your solution would be fine. But we don't. The clocksource model (/sys/devices/system/clocksource) is a better way to go. One sysfs file is used to enumerate the possible sources and another is used to read or set the current source. No new system calls; no new ioctls. -ch ch (at) murgatroid (dot) com ch (at) hpl (dot) hp (dot) com ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-08-01 22:14 ` Christopher Hoover @ 2007-08-01 23:03 ` Satyam Sharma 0 siblings, 0 replies; 43+ messages in thread From: Satyam Sharma @ 2007-08-01 23:03 UTC (permalink / raw) To: Christopher Hoover; +Cc: linux-kernel Hi, On Wed, 1 Aug 2007, Christopher Hoover wrote: > Satyam Sharma <satyam <at> infradead.org> writes: > > On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > > > > > On Mon, Jul 30, 2007 at 10:33:35AM +0530, Satyam Sharma wrote: > > > Currently the RFC says to you that you should open the serial port: > > > > > > fd = open("/dev/ttyS0", ...); > > > > No, it does *NOT*. All it says is: > > > > The time_pps_create() is used to convert an already-open UNIX file > > descriptor, for an appropriate special file, into a PPS handle. > > > > See? What I said is precisely the implementation the RFC envisages > > (and the only sane way to implement it too). > > If we were totally rigurous about representing each device as a device node, > your solution would be fine. But we don't. Of course. > The clocksource model (/sys/devices/system/clocksource) is a better way to > go. One sysfs file is used to enumerate the possible sources and another is > used to read or set the current source. No new system calls; no new ioctls. Oh, not introducing any syscalls _at all_ would be fine, too. But the RFC does /require/ an implementation to have them. I was only mentioning the kind of implementation the RFC had in mind. But there are other ways to achieve the same end goal, and yes, probably it's better to avoid introducing syscalls in the first place and think of other mechanisms. [ It's not that we're talking of IPsec or IPv6 or something here -- so RFC-compliance isn't overly important. But the final result needs to be good, secure and well-designed, still. ] Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 23:41 ` Satyam Sharma 2007-07-29 9:50 ` Rodolfo Giometti @ 2007-07-29 9:57 ` Rodolfo Giometti 2007-07-29 10:00 ` Rodolfo Giometti 2 siblings, 0 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-29 9:57 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote: > > Ok, I've looked through (most of) the RFC and code now, and am only > commenting on a design-level for now. Anyway, I didn't like the way > you've significantly drifted from the RFC in several ways: Please, read documentation file Documentation/pps/pps.txt where I exaplain why I did such RFC changes in my implementation. Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 23:41 ` Satyam Sharma 2007-07-29 9:50 ` Rodolfo Giometti 2007-07-29 9:57 ` Rodolfo Giometti @ 2007-07-29 10:00 ` Rodolfo Giometti 2007-07-30 5:09 ` Satyam Sharma 2 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-29 10:00 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote: > Take the race between the time_pps_setparams() syscall and a concurrent > pps_event() from an interrupt for instance. From sys_time_pps_setparams, > the parameters for an existing source are not modified / set atomically, > which means a pps_event() called on the same source in between will see > invalid parameters ... and bad things will happen. I think this should be a good solution... :) diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c index 08de71d..f0c42ec 100644 --- a/drivers/pps/kapi.c +++ b/drivers/pps/kapi.c @@ -29,12 +29,6 @@ #include <linux/pps.h> /* - * Local variables - */ - -static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED; - -/* * Local functions */ diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c index 9176c01..91b7e4d 100644 --- a/drivers/pps/pps.c +++ b/drivers/pps/pps.c @@ -35,6 +35,7 @@ struct pps_s pps_source[PPS_MAX_SOURCES]; DEFINE_MUTEX(pps_mutex); +spinlock_t pps_lock = SPIN_LOCK_UNLOCKED; /* * Misc functions @@ -227,6 +228,8 @@ asmlinkage long sys_time_pps_setparams(int source, goto sys_time_pps_setparams_exit; } + spin_lock(&pps_lock); + /* Save the new parameters */ ret = copy_from_user(&pps_source[source].params, params, sizeof(struct pps_kparams)); @@ -245,6 +248,8 @@ asmlinkage long sys_time_pps_setparams(int source, pps_source[source].params.mode |= PPS_CANWAIT; pps_source[source].params.api_version = PPS_API_VERS; + spin_unlock(&pps_lock); + sys_time_pps_setparams_exit: mutex_unlock(&pps_mutex); diff --git a/include/linux/pps.h b/include/linux/pps.h index 6eca3ea..93e7384 100644 --- a/include/linux/pps.h +++ b/include/linux/pps.h @@ -174,6 +174,7 @@ struct pps_s { extern struct pps_s pps_source[PPS_MAX_SOURCES]; extern struct mutex pps_mutex; +extern spinlock_t pps_lock; /* * Global functions Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply related [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-29 10:00 ` Rodolfo Giometti @ 2007-07-30 5:09 ` Satyam Sharma 2007-07-30 8:53 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 5:09 UTC (permalink / raw) To: Rodolfo Giometti Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi Rodolfo, On Sun, 29 Jul 2007, Rodolfo Giometti wrote: > On Sat, Jul 28, 2007 at 05:11:17AM +0530, Satyam Sharma wrote: > > > Take the race between the time_pps_setparams() syscall and a concurrent > > pps_event() from an interrupt for instance. From sys_time_pps_setparams, > > the parameters for an existing source are not modified / set atomically, > > which means a pps_event() called on the same source in between will see > > invalid parameters ... and bad things will happen. > > I think this should be a good solution... :) > > diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c > index 08de71d..f0c42ec 100644 > --- a/drivers/pps/kapi.c > +++ b/drivers/pps/kapi.c > @@ -29,12 +29,6 @@ > #include <linux/pps.h> > > /* > - * Local variables > - */ > - > -static spinlock_t pps_lock = SPIN_LOCK_UNLOCKED; > - > -/* > * Local functions > */ > > diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c > index 9176c01..91b7e4d 100644 > --- a/drivers/pps/pps.c > +++ b/drivers/pps/pps.c > @@ -35,6 +35,7 @@ > > struct pps_s pps_source[PPS_MAX_SOURCES]; > DEFINE_MUTEX(pps_mutex); > +spinlock_t pps_lock = SPIN_LOCK_UNLOCKED; > > /* > * Misc functions > @@ -227,6 +228,8 @@ asmlinkage long sys_time_pps_setparams(int source, > goto sys_time_pps_setparams_exit; > } > > + spin_lock(&pps_lock); > + > /* Save the new parameters */ > ret = copy_from_user(&pps_source[source].params, params, > sizeof(struct pps_kparams)); > @@ -245,6 +248,8 @@ asmlinkage long sys_time_pps_setparams(int source, > pps_source[source].params.mode |= PPS_CANWAIT; > pps_source[source].params.api_version = PPS_API_VERS; > > + spin_unlock(&pps_lock); > + > sys_time_pps_setparams_exit: > mutex_unlock(&pps_mutex); Nopes, this isn't quite correct/safe. I suggest you should read: http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/ Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 5:09 ` Satyam Sharma @ 2007-07-30 8:53 ` Rodolfo Giometti 2007-07-30 9:31 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-30 8:53 UTC (permalink / raw) To: Satyam Sharma Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Mon, Jul 30, 2007 at 10:39:38AM +0530, Satyam Sharma wrote: > > Nopes, this isn't quite correct/safe. I suggest you should read: > > http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/ I read it but still I don't see why my solution isn't correct/safe. :) Can you please propose to me your solution? Thanks a lot for you time! Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 8:53 ` Rodolfo Giometti @ 2007-07-30 9:31 ` Satyam Sharma 0 siblings, 0 replies; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 9:31 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi Rodolfo, On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > On Mon, Jul 30, 2007 at 10:39:38AM +0530, Satyam Sharma wrote: > > > > Nopes, this isn't quite correct/safe. I suggest you should read: > > > > http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/ > > I read it but still I don't see why my solution isn't correct/safe. :) What does the section on locking between hard irq contexts (or between user process context and hard irq context) say? > Can you please propose to me your solution? As I said, you could just use the spin_lock_irqsave/restore() variants ... If you want, I can try and implement the other bits that I had suggested for the other things as well :-) Ciao, Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-27 20:47 ` Satyam Sharma 2007-07-27 23:41 ` Satyam Sharma @ 2007-07-29 9:17 ` Rodolfo Giometti 2007-07-30 4:19 ` Satyam Sharma 1 sibling, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-29 9:17 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Sat, Jul 28, 2007 at 02:17:24AM +0530, Satyam Sharma wrote: > > I only glanced through the code, so could be wrong, but I noticed that > the only global / shared data you have in there is a global "pps_source" > array of pps_s structs. That's accessed / modified from the various > syscalls introduced in the API exported to userspace, as well as the > register/unregister/pps_event API exported to in-kernel client subsystems, > yes? So it looks like you need to introduce proper locking for it, simply > type-qualifying it as "volatile" is not enough. > > However, I think you've introduced two locks for it. The syscalls (that > run in process context, obviously) seem to use a pps_mutex and > pps_event() seems to be using the pps_lock spinlock (because that > gets executed from interrupt context) -- and from the looks of it, the > register/unregister functions are using /both/ the mutex and spinlock (!) This is right. > This isn't quite right, (in fact there's nothing to protect pps_event from > racing against a syscall), so you should use *only* the spinlock for > synchronization -- the spin_lock_irqsave/restore() variants, in fact. We can't use the spin_lock_irqsave/restore() variants since PPS sources cannot manage IRQ enable/disable. For instance, the serial source doesn't manage IRQs directly but just uses it to record PPS events. The serial driver manages the IRQ enable/disable, not the PPS source which only uses the IRQ handler to records events. About using both mutex and spinlock I did it since (I think) I should protect syscalls from each others and from pps_register/unregister(), and pps_event() against pps_register/unregister(). > [ Also, have you considered making pps_source a list and not an array? > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc > kind of gymnastics in there, and you _can_ return a pointer to the > corresponding pps source struct from the register() function to the in-kernel > users, so that way you get to retain the O(1) access to the corresponding > source when a client calls into pps_event(), similar to how you're using the > array index presently. ] > > I also noticed code like (from pps_event): > > + /* Try to grab the lock, if not we prefere loose the event... */ > + if (!spin_trylock(&pps_lock)) > + return; > > which looks worrisome and unnecessary. That spinlock looks to be of > fine enough granularity to me, do you think there'd be any contention > on it? I /think/ you can simply make that a spin_lock(). This is due the fact I cannot manage IRQ enable/disable. > Overall the code looks simple / straightforward enough to me (except for > the parport / uart stuff that I have no clue about), and I'll also read up on > the relevant RFC for this and would hopefully try and give you a more > meaningful review over the weekend. Thanks a lot for your help! Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-29 9:17 ` Rodolfo Giometti @ 2007-07-30 4:19 ` Satyam Sharma 2007-07-30 8:32 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 4:19 UTC (permalink / raw) To: Rodolfo Giometti Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi Rodolfo, On Sun, 29 Jul 2007, Rodolfo Giometti wrote: > On Sat, Jul 28, 2007 at 02:17:24AM +0530, Satyam Sharma wrote: > > > > I only glanced through the code, so could be wrong, but I noticed that > > the only global / shared data you have in there is a global "pps_source" > > array of pps_s structs. That's accessed / modified from the various > > syscalls introduced in the API exported to userspace, as well as the > > register/unregister/pps_event API exported to in-kernel client subsystems, > > yes? So it looks like you need to introduce proper locking for it, simply > > type-qualifying it as "volatile" is not enough. > > > > However, I think you've introduced two locks for it. The syscalls (that > > run in process context, obviously) seem to use a pps_mutex and > > pps_event() seems to be using the pps_lock spinlock (because that > > gets executed from interrupt context) -- and from the looks of it, the > > register/unregister functions are using /both/ the mutex and spinlock (!) > > This is right. > > > This isn't quite right, (in fact there's nothing to protect pps_event from > > racing against a syscall), so you should use *only* the spinlock for > > synchronization -- the spin_lock_irqsave/restore() variants, in fact. > > We can't use the spin_lock_irqsave/restore() variants since PPS > sources cannot manage IRQ enable/disable. For instance, the serial > source doesn't manage IRQs directly but just uses it to record PPS > events. The serial driver manages the IRQ enable/disable, not the PPS > source which only uses the IRQ handler to records events. Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore() in pps_event() around the access to pps_source. > About using both mutex and spinlock I did it since (I think) I should > protect syscalls from each others and from pps_register/unregister(), > and pps_event() against pps_register/unregister(). Nopes, it's not about protecting code from each other, you're needlessly complicating things. Locking is pretty simple, really -- any shared data, that can be concurrently accessed by multiple threads (or from interrupts) must be protected with a lock. Note that *data* is protected by a lock, and not "code" that handles it (well, this is the kind of behaviour most cases need, at least, including yours). So here we're introducing the lock to protect *pps_source*, and not keep *threads* of execution from stepping over each other. So, simply, just ensure you grab the lock whenever you want to start accessing the shared data, and release it when you're done. The _irqsave/restore() variants are required because (say) one of the syscalls executing in process context grabs the spinlock. Then, before it has released it, it gets interrupted and pps_event() begins executing. Now pps_event() also wants to grab the lock, but the syscall already has it, so will continue spinning and deadlock! > > [ Also, have you considered making pps_source a list and not an array? > > It'll help you lose a whole lot of MAX_SOURCES, pps_is_allocated, etc > > kind of gymnastics in there, and you _can_ return a pointer to the > > corresponding pps source struct from the register() function to the in-kernel > > users, so that way you get to retain the O(1) access to the corresponding > > source when a client calls into pps_event(), similar to how you're using the > > array index presently. ] > > > > I also noticed code like (from pps_event): > > > > + /* Try to grab the lock, if not we prefere loose the event... */ > > + if (!spin_trylock(&pps_lock)) > > + return; > > > > which looks worrisome and unnecessary. That spinlock looks to be of > > fine enough granularity to me, do you think there'd be any contention > > on it? I /think/ you can simply make that a spin_lock(). > > This is due the fact I cannot manage IRQ enable/disable. What I meant is that you could make it a proper spin_lock() -- or spin_lock_irqsave(), actually -- instead of the _trylock_ variant that it currently is. I think you're unnecessarily worrying about contention here -- you can have multiple locks (one for the list, and separate ones for your sources) if you're really worrying about contention -- or probably rwlocks. But really, rwlocks would end up being *slower* than spinlocks, unless the contention is really heavy and it helps to keep multiple readers in the critical section. But frankly, with at max a few (I'd expect generally one) PPS sources ever to be connected / registered with teh system, and just one-pulse-per-second, I don't see why any contention is ever gonna happen. Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 4:19 ` Satyam Sharma @ 2007-07-30 8:32 ` Rodolfo Giometti 2007-07-30 9:07 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-30 8:32 UTC (permalink / raw) To: Satyam Sharma Cc: Satyam Sharma, Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Mon, Jul 30, 2007 at 09:49:20AM +0530, Satyam Sharma wrote: > > Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore() > in pps_event() around the access to pps_source. In pps_event() is not useful using spin_lock_irqsave/restore() since the only difference between spin_lock_irqsave() and spin_lock() is that the former will turn off interrupts if they are on, otherwise does nothing (if we are already in an interrupt handler). Maybe you meant I should using spin_lock_irqsave/restore() in user context, but doing like this I will disable interrupts and I don't wish doing it since, in this manner, the interrupt handler will be delayed and the (probably) PPS event recording will be wrong. I prefere loosing the event that registering it at delayed time. > > About using both mutex and spinlock I did it since (I think) I should > > protect syscalls from each others and from pps_register/unregister(), > > and pps_event() against pps_register/unregister(). > > Nopes, it's not about protecting code from each other, you're needlessly > complicating things. Locking is pretty simple, really -- any shared data, > that can be concurrently accessed by multiple threads (or from interrupts) > must be protected with a lock. Note that *data* is protected by a lock, > and not "code" that handles it (well, this is the kind of behaviour most > cases need, at least, including yours). Of course, I meant "protecting data". In fact to protect pps_source[] I need spin_lock() to protect user context from interrupt context and mutex to protect user context from itself. > So here we're introducing the lock to protect *pps_source*, and not keep > *threads* of execution from stepping over each other. So, simply, just > ensure you grab the lock whenever you want to start accessing the shared > data, and release it when you're done. I see. But consider pps_register_source(). This function should provide protection of pps_source against both interrupt context (pps_event()) and user context (maybe pps_unregister_source() or one syscalls). Using only mutex is not possible, since we cannot use mutex in interrupt context, and using only spin_locks is not possible since in UP() they became void. Can you please show me how I could write pps_register_source() in order to be correct from your point of view? > The _irqsave/restore() variants are required because (say) one of the > syscalls executing in process context grabs the spinlock. Then, before it > has released it, it gets interrupted and pps_event() begins executing. > Now pps_event() also wants to grab the lock, but the syscall already > has it, so will continue spinning and deadlock! That's the point. I don't wish using _irqsave/restore() since they may delay interrupt handler execution. As above, I prefere loosing the event then registering it at wrong time. > I think you're unnecessarily worrying about contention here -- you can > have multiple locks (one for the list, and separate ones for your sources) > if you're really worrying about contention -- or probably rwlocks. But > really, rwlocks would end up being *slower* than spinlocks, unless the > contention is really heavy and it helps to keep multiple readers in the > critical section. But frankly, with at max a few (I'd expect generally > one) PPS sources ever to be connected / registered with teh system, and > just one-pulse-per-second, I don't see why any contention is ever gonna > happen. Why you wish using one lock per sources? Just one lock for the list/array is not enought? :-o Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 8:32 ` Rodolfo Giometti @ 2007-07-30 9:07 ` Satyam Sharma 2007-07-30 14:55 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 9:07 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi, On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > On Mon, Jul 30, 2007 at 09:49:20AM +0530, Satyam Sharma wrote: > > > > Hmm? I still don't see why you can't introduce spin_lock_irqsave/restore() > > in pps_event() around the access to pps_source. > > In pps_event() is not useful using spin_lock_irqsave/restore() since > the only difference between spin_lock_irqsave() and spin_lock() is > that the former will turn off interrupts if they are on, otherwise > does nothing (if we are already in an interrupt handler). Yup. But two pps_event()'s on different CPU's could still race. > Maybe you meant I should using spin_lock_irqsave/restore() in user > context, but doing like this I will disable interrupts Yup, but the goal is to avoid races. Otherwise why bother doing any locking at all? > and I don't > wish doing it since, in this manner, the interrupt handler will be > delayed and the (probably) PPS event recording will be wrong. I > prefere loosing the event that registering it at delayed time. What you're risking is not "losing an event" (which, btw, you should not be, either), but a *deadlock*. > > > About using both mutex and spinlock I did it since (I think) I should > > > protect syscalls from each others and from pps_register/unregister(), > > > and pps_event() against pps_register/unregister(). > > > > Nopes, it's not about protecting code from each other, you're needlessly > > complicating things. Locking is pretty simple, really -- any shared data, > > that can be concurrently accessed by multiple threads (or from interrupts) > > must be protected with a lock. Note that *data* is protected by a lock, > > and not "code" that handles it (well, this is the kind of behaviour most > > cases need, at least, including yours). > > Of course, I meant "protecting data". In fact to protect pps_source[] > I need spin_lock() to protect user context from interrupt context and > mutex to protect user context from itself. But that's nonsensical! That's not how you implement locking! First, spin_lock() is *not* enough to protect access from process context from access from interrupt context. Second, if you *already* have a lock to protect any data, introducing *another* lock to protect the same data is ... utterly crazy! > > So here we're introducing the lock to protect *pps_source*, and not keep > > *threads* of execution from stepping over each other. So, simply, just > > ensure you grab the lock whenever you want to start accessing the shared > > data, and release it when you're done. > > I see. But consider pps_register_source(). This function should > provide protection of pps_source against both interrupt context > (pps_event()) and user context (maybe pps_unregister_source() or one > syscalls). Using only mutex is not possible, since we cannot use mutex > in interrupt context, and using only spin_locks is not possible since > in UP() they became void. Yup, but that's okay. On UP, spin_lock_irqsave() becomes local_irq_save() which is what you want anyway on UP. > Can you please show me how I could write pps_register_source() in > order to be correct from your point of view? The simplest, most straightforward, and safest, most correct, way would be to just use spin_lock_irqsave/restore() to around all access to the shared/global data, from _any_ context. Anyway, I'll try and see if I find some time this week to implement what I was mentioning ... > > The _irqsave/restore() variants are required because (say) one of the > > syscalls executing in process context grabs the spinlock. Then, before it > > has released it, it gets interrupted and pps_event() begins executing. > > Now pps_event() also wants to grab the lock, but the syscall already > > has it, so will continue spinning and deadlock! > > That's the point. I don't wish using _irqsave/restore() since they may > delay interrupt handler execution. As above, I prefere loosing the > event then registering it at wrong time. Ok, think of it this way -- you don't have an option. You just *have* to use them. As I said, please read Rusty Russell's introduction to locking in the kernel. > > I think you're unnecessarily worrying about contention here -- you can > > have multiple locks (one for the list, and separate ones for your sources) > > if you're really worrying about contention -- or probably rwlocks. But > > really, rwlocks would end up being *slower* than spinlocks, unless the > > contention is really heavy and it helps to keep multiple readers in the > > critical section. But frankly, with at max a few (I'd expect generally > > one) PPS sources ever to be connected / registered with teh system, and > > just one-pulse-per-second, I don't see why any contention is ever gonna > > happen. > > Why you wish using one lock per sources? Just one lock for the > list/array is not enought? :-o No, I am *not* wishing / advocating that at all. Just that you appear so _reluctant_ to use spinlocks and are unnecessarily worrying about contention, disabling interrupts, etc etc. Just use the spin_lock_irqsave/restore() variants, and you'll be fine. Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 9:07 ` Satyam Sharma @ 2007-07-30 14:55 ` Rodolfo Giometti 2007-07-30 22:01 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-30 14:55 UTC (permalink / raw) To: Satyam Sharma Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton, Satyam Sharma On Mon, Jul 30, 2007 at 02:37:26PM +0530, Satyam Sharma wrote: > On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > > > > In pps_event() is not useful using spin_lock_irqsave/restore() since > > the only difference between spin_lock_irqsave() and spin_lock() is > > that the former will turn off interrupts if they are on, otherwise > > does nothing (if we are already in an interrupt handler). > > Yup. But two pps_event()'s on different CPU's could still race. ??? :-o Maybe one CPU spins 'till the other holds the lock but any races should happen... > > Maybe you meant I should using spin_lock_irqsave/restore() in user > > context, but doing like this I will disable interrupts > > Yup, but the goal is to avoid races. Otherwise why bother doing any > locking at all? I meant that if you have to lock between user context and interrupt context you have two choises: 1) using spin_lock_irqsave/restore() in user context and spin_lock/unlock() in the interrupt context (as Rusty says), 2) or using spin_lock/unlock() in user context and spin_trylock/unlock() in the interrupt context in order to avoid dead locks. Is that correct? > > Of course, I meant "protecting data". In fact to protect pps_source[] > > I need spin_lock() to protect user context from interrupt context and > > mutex to protect user context from itself. > > But that's nonsensical! That's not how you implement locking! > > First, spin_lock() is *not* enough to protect access from process context > from access from interrupt context. > > Second, if you *already* have a lock to protect any data, introducing > *another* lock to protect the same data is ... utterly crazy! I see what you mean. But my question is about using spin_locks where we can sleep. Let me explain, consider sys_time_pps_getparams(): asmlinkage long sys_time_pps_getparams(int source, struct pps_kparams __user *params) { int ret = 0; pr_debug("%s: source %d\n", __FUNCTION__, source); /* Sanity checks */ if (!params) return -EINVAL; if (mutex_lock_interruptible(&pps_mutex)) return -EINTR; ret = pps_check_source(source); if (ret < 0) { ret = -ENODEV; goto sys_time_pps_getparams_exit; } /* Return current parameters */ ret = copy_to_user(params, &pps_source[source].params, sizeof(struct pps_kparams)); if (ret) ret = -EFAULT; sys_time_pps_getparams_exit: mutex_unlock(&pps_mutex); return ret; } The copy_to_user() may sleep and if I change mutex_lock_interruptible() with a spin_lock I may hold it and then going to sleep... using mutex we can use the CPU for other computations. > > I see. But consider pps_register_source(). This function should > > provide protection of pps_source against both interrupt context > > (pps_event()) and user context (maybe pps_unregister_source() or one > > syscalls). Using only mutex is not possible, since we cannot use mutex > > in interrupt context, and using only spin_locks is not possible since > > in UP() they became void. > > Yup, but that's okay. On UP, spin_lock_irqsave() becomes local_irq_save() > which is what you want anyway on UP. But doing like this may happen that I first execute local_irq_save() and then go to sleep due copy_to_user()? :-o > The simplest, most straightforward, and safest, most correct, way would > be to just use spin_lock_irqsave/restore() to around all access to the > shared/global data, from _any_ context. Even if I may sleep while holding a spinlock? Rusty says here (http://www.kernel.org/pub/linux/kernel/people/rusty/kernel-locking/c557.html) that: Many functions in the kernel sleep (ie. call schedule()) directly or indirectly: you can never call them while __holding a spinlock__, or with preemption disabled. This also means you need to be in user context: calling them from an interrupt is illegal. > Anyway, I'll try and see if I find some time this week to implement > what I was mentioning ... Thanks a lot, so we can discuss on code. :) > > That's the point. I don't wish using _irqsave/restore() since they may > > delay interrupt handler execution. As above, I prefere loosing the > > event then registering it at wrong time. > > Ok, think of it this way -- you don't have an option. You just *have* > to use them. As I said, please read Rusty Russell's introduction to > locking in the kernel. I see but I don't see why using spin_lock/unlock() in user contex and spin_trylock/unlock() in interrupt context is wrong. :) > > Why you wish using one lock per sources? Just one lock for the > > list/array is not enought? :-o > > No, I am *not* wishing / advocating that at all. Just that you appear so > _reluctant_ to use spinlocks and are unnecessarily worrying about > contention, disabling interrupts, etc etc. > > Just use the spin_lock_irqsave/restore() variants, and you'll be fine. What I wish is just to avoid disabling IRQs in user context in order to minimize the possibility to delay events recording. We this requirement the only solution I see is using spin_trylock/unlock() in interrupt context. Another requirement is __not__ going to sleep while holding a spinlock (as Rusty says) and again the only solution I see is using mutex. Looking at my previous patch I found that it should be written like this: @@ -199,6 +200,7 @@ asmlinkage long sys_time_pps_setparams(int source, const struct pps_kparams __user *params) { int ret; + struct pps_kparams temp; pr_debug(``%s: source %d\n'', __FUNCTION__, source); @@ -228,13 +230,16 @@ asmlinkage long sys_time_pps_setparams(int source, } /* Save the new parameters */ - ret = copy_from_user(&pps_source[source].params, params, - sizeof(struct pps_kparams)); + ret = copy_from_user(&temp, params, sizeof(struct pps_kparams)); if (ret) { ret = -EFAULT; goto sys_time_pps_setparams_exit; } + spin_lock(&pps_lock); + + pps_source[source].params = temp; + /* Restore the read only parameters */ if ((params->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { /* section 3.3 of RFC 2783 interpreted */ @@ -245,6 +250,8 @@ asmlinkage long sys_time_pps_setparams(int source, pps_source[source].params.mode |= PPS_CANWAIT; pps_source[source].params.api_version = PPS_API_VERS; + spin_unlock(&pps_lock); + sys_time_pps_setparams_exit: mutex_unlock(&pps_mutex); In this manner I can going to sleep in copy_from_user() whitout holding any locks. On Mon, Jul 30, 2007 at 02:50:56PM +0530, Satyam Sharma wrote: > > No, it does *NOT*. All it says is: > > The time_pps_create() is used to convert an already-open UNIX file > descriptor, for an appropriate special file, into a PPS handle. > > See? What I said is precisely the implementation the RFC envisages > (and the only sane way to implement it too). > > And later, where it gives an example, it shows: > > fd = open(PPSfilename, O_RDWR, 0); > > What I'm saying is that the "PPSfilename", as is obvious from the name > itself, is *not* a port such as lpXXX or ttySXXX, but an "appropriate > special file" corresponding to a ... PPS source! Really, the RFC is > quite clear and easy to read, I have no idea how to explain that more > clearly ... Ok, I see, but how you can get your PPS source data struct starting from a file descriptor? :-o > > As you propose you need _two_ open() and not just one... > > No, why? Please, take alook at NTPD code. Common usage is: fd = open("/dev/ttyS0", ...); pps_time_create(fd, &handler); since RFC supposes that at filedes "fd" is mapped both GPS data _and_ PPS source. With your suggestion code should be changed as follow: fd_gps = open("/dev/ttyS0", ...); fd_pps = open("/dev/pps0", ...); pps_time_create(fd_pps, &handler); > > and even if > > you decide to open the /dev/ppsX inside the pps_time_create(), how do > > you recognise _which_ /dev/ppsX is connected with filedse "fd"? > > That's trivial to implement in the kernel code for the time_pps_create() > syscall. I didn't find a good solution for it. Furthermore with my pps_findpath() I can do: fd = open("/dev/ttyS0", ...); handler = pps_findpath("/dev/ttyS0", ...); which in most cases its more easy to manage for both user and kernel land. Can do the same with char devices? Maybe you can easily create /dev/pps0 but how can you relate it with the /dev/ttyS0 if your GPS antenna and PPS source share the same serial port? I studied the problem trying to find a good solution for both NTPD code (tring to change it as less as possible) and PPS sources connected with CPU's GPIOs, but currently I find nothing better that this. > > I quite sure that RFC is broken since it doesn't take in account that > > a PPS source maybe not connected with any cahr device at all. I tried > > to explain this problem to RFC's gurus but they never answered to me, > > so I decided to resolve the problem by myself. ;) > > Nopes, the RFC is not broken at all. All this physical-connection-port > device vs PPS-source-device confusion is just in your mind :-) Ok, if you don't think so try looking at NTPD code (written by RFC's gurus) and try to resolve the problem where both GPS antenna and PPS source are connected with a serial port, and the problem where only the GPS antenna is connected with the serial port but the PPS source is connected with a CPU's GPIO. If you solve both them all PPS users will thank you a lot forever! :) > > Ok, but in this case you still are _not_ RFC compliant (as showed > > above). You need that users give to you _two_ devices (the serial line > > and the PPS source), meanwhile, for the RFC, you just need one. So no > > differences from my solution from this point of view. > > Yeah, so how am I not RFC compliant? Userspace will *only* open(2) the > special char device of the *PPS source*, and have *nothing* to do with > the device corresponding to the physical device/port it is connected > through! Ok, in your sceraio no problem, but continue to read RFC: All of the other functions in the PPS API operate on PPS handles (type: pps_handle_t). The time_pps_create() is used to convert an already-open UNIX file descriptor, for an appropriate special file, into a PPS handle. The definition of what special files are appropriate for use with the PPS API is outside the scope of this specification, and may vary based on both operating system implementation, and local system configuration. One typical case is a serial line, whose DCD pin is connected to a source of PPS events. This shows that RFC creators though only at PPS sources connected with an _already_ opened device (as serial ports or parallel one), if not why don't define the function time_pps_create() as: int time_pps_create(char *ppsdev, pps_handle_t *handle); ??? No, they require an _already_ opened file descriptor because they supposed you can use serial line file descriptor! So, if this is not your case (because your PPS source is connected with a CPU's GPIO) you _must_ use a second open() (not considere at all into NTPD code) or, as I did, use a special function like pps_findsource/path(). > > I need them (or just one of them) in order to find a PPS source into > > the system. Just as you need the second device name in your solution > > with char devices. > > No, I don't need any "second device". I *only* need the "appropriate > special file" as mentioned in the RFC. I don't give a *damn* for > what *physical device/port* the source is actually connected through. > I suggest you should read the RFC again ... I read it. Ok, according your solution and not considering the two open()s to do we should do: fd_pps = open("/dev/pps0", ...); time_pps_create(fd_pps, &handle); ok? Two qeustions: 1) If the RFC wan't broken why it doesn't simply say that you can use fd_pps and pps handler? 2) How can you get kernel PPS source data just getting as input fd_pps value? Again, RFC was sane if it said that you can get a PPS hadler by simply doing: time_pps_create("/dev/pps0", &handle); this could be easily implemented with just an open()... They didn't like this because they __never__ considered the case where the PPS source is not connected at all with any serial/parallel decices. On Mon, Jul 30, 2007 at 03:01:28PM +0530, Satyam Sharma wrote: > > What does the section on locking between hard irq contexts (or between > user process context and hard irq context) say? That I should use spin_lock_irqsave() but the document also: 1) says that I cannot hold spinlocks while sleeping and 2) doesn't say that using spin_lock/unlock() in user context and spin_trylock/unlock() in interrupt context is wrong. > As I said, you could just use the spin_lock_irqsave/restore() variants ... > If you want, I can try and implement the other bits that I had suggested > for the other things as well :-) Great! Thanks a lot, so we can discuss on them and maybe we can prive Linux of this PPS support! :) Thanks a lot for your time, this discussion was most important for me in better understanding locks problems (and also to improve my poor english, eheheheh :). Ciao, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 14:55 ` Rodolfo Giometti @ 2007-07-30 22:01 ` Satyam Sharma 2007-07-31 8:20 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-30 22:01 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi Rodolfo, On Mon, 30 Jul 2007, Rodolfo Giometti wrote: > On Mon, Jul 30, 2007 at 02:37:26PM +0530, Satyam Sharma wrote: > > > > Maybe you meant I should using spin_lock_irqsave/restore() in user > > > context, but doing like this I will disable interrupts > > > > Yup, but the goal is to avoid races. Otherwise why bother doing any > > locking at all? > > I meant that if you have to lock between user context and interrupt > context you have two choises: > > 1) using spin_lock_irqsave/restore() in user context and spin_lock/unlock() > in the interrupt context (as Rusty says), Yes, but we need to use spin_lock_irqsave() from interrupt context to synchronize between two hard irq contexts themselves. > 2) or using spin_lock/unlock() in user context and > spin_trylock/unlock() in the interrupt context in order to avoid dead > locks. Yup, this would avoid races, but then we will lose events. Why is that acceptable, when better alternative (above) exists? Seriously, your aversion to implement good, safe locking is amazing! :-) > > > Of course, I meant "protecting data". In fact to protect pps_source[] > > > I need spin_lock() to protect user context from interrupt context and > > > mutex to protect user context from itself. > > > > But that's nonsensical! That's not how you implement locking! > > > > First, spin_lock() is *not* enough to protect access from process context > > from access from interrupt context. > > > > Second, if you *already* have a lock to protect any data, introducing > > *another* lock to protect the same data is ... utterly crazy! > > I see what you mean. But my question is about using spin_locks where > we can sleep. Let me explain, consider sys_time_pps_getparams(): > [...] > The copy_to_user() may sleep and if I change > mutex_lock_interruptible() with a spin_lock I may hold it and then > going to sleep... using mutex we can use the CPU for other > computations. The proper way to do this is to use a kernel buffer to do all kernel-side work (you acquire/release lock during that work) and then copy_to_user() later, at the end. [ And something opposite for the set_xxx syscall, i.e. first off copy_from_user() to a kernel buffer up front, before doing anything else itself, and then do all the work in the kernel on that. ] BTW your syscall implementations totally lack any kind of security checks whatsoever ... > > > Why you wish using one lock per sources? Just one lock for the > > > list/array is not enought? :-o > > > > No, I am *not* wishing / advocating that at all. Just that you appear so > > _reluctant_ to use spinlocks and are unnecessarily worrying about > > contention, disabling interrupts, etc etc. > > > > Just use the spin_lock_irqsave/restore() variants, and you'll be fine. > > What I wish is just to avoid disabling IRQs in user context in order > to minimize the possibility to delay events recording. Amazing. On the one hand, you want to use spin_trylock() in the hard irq handler and spin_lock() (not irq safe) in the process context, because you "don't care about losing some events". And now you want to avoid "disabling irqs in user context to minimize possibility to delay events recording"? Anyway, any such requirement you're talking about is just bogus, IMHO. You're just disabling interrupts to access a data structure, for Gods' sakes, how many nanoseconds do you imagine would you be "delaying"? > > > As you propose you need _two_ open() and not just one... > > > > No, why? > > Please, take alook at NTPD code. Common usage is: > > fd = open("/dev/ttyS0", ...); > > pps_time_create(fd, &handler); > > since RFC supposes that at filedes "fd" is mapped both GPS data _and_ > PPS source. Umm, I don't think the RFC supposes/assumes this anywhere. > Furthermore with my pps_findpath() I can do: > > fd = open("/dev/ttyS0", ...); > > handler = pps_findpath("/dev/ttyS0", ...); > > which in most cases its more easy to manage for both user and kernel > land. > > Can do the same with char devices? Of course. BTW time_pps_findpath/findsource do not have to be kernel implemented syscalls in the first place. The best, simplest and most straightforward place to implement them is in userspace -- the RFC mentions this as well. > Maybe you can easily create > /dev/pps0 but how can you relate it with the /dev/ttyS0 if your GPS > antenna and PPS source share the same serial port? A solution I can think of is to create a mapping at the time of pps_register_source() between the PPS source (physically) and the special char device. Userspace open(2)'s the special char device corresponding to the PPS source, and then issues the time_pps_create() syscall. Here, we lookup the mapping previously created and return handle to the PPS source based on the special device's fd that's passed to us in time_pps_create(). > > > I quite sure that RFC is broken since it doesn't take in account that > > > a PPS source maybe not connected with any cahr device at all. I tried > > > to explain this problem to RFC's gurus but they never answered to me, > > > so I decided to resolve the problem by myself. ;) > > > > Nopes, the RFC is not broken at all. All this physical-connection-port > > device vs PPS-source-device confusion is just in your mind :-) > > Ok, if you don't think so try looking at NTPD code (written by RFC's > gurus) and try to resolve the problem where both GPS antenna and PPS > source are connected with a serial port, and the problem where only > the GPS antenna is connected with the serial port but the PPS source > is connected with a CPU's GPIO. > > If you solve both them all PPS users will thank you a lot forever! :) Ok, I'll take a look, thanks :-) [ what's the URL for these sources? ] > No, they require an _already_ opened file descriptor because they > supposed you can use serial line file descriptor! open(PPSfilename, O_RDWR) doesn't sound like that at all. If the device for the serial port / parport was intended, it wouldn't be called "PPSfilename", would it? > Again, RFC was sane if it said that you can get a PPS hadler by simply > doing: > > time_pps_create("/dev/pps0", &handle); > > this could be easily implemented with just an open()... > > They didn't like this because they __never__ considered the case where > the PPS source is not connected at all with any serial/parallel > decices. The physical port/device through which a PPS source is connected is immaterial. Anyway, I'll take a look at the NTPD/userspace code you are mentioning as well. [ again, could you point me to URL of source code? ] > > If you want, I can try and implement the other bits that I had suggested > > for the other things as well :-) > > Great! Thanks a lot, so we can discuss on them and maybe we can prive > Linux of this PPS support! :) Sure, I'll get to implementing what I have in mind here -- will be glad to be of any help, thanks. Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-30 22:01 ` Satyam Sharma @ 2007-07-31 8:20 ` Rodolfo Giometti 2007-07-31 18:49 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-31 8:20 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Tue, Jul 31, 2007 at 03:31:22AM +0530, Satyam Sharma wrote: > Hi Rodolfo, Hi :) > Yup, this would avoid races, but then we will lose events. Why is that > acceptable, when better alternative (above) exists? Because is better lossign events then recording them delayed. In the past we (LinuxPPS users) noticed that just postponing of one instruction the timestamp recording degrade the timesetting of about 50%! > Seriously, your aversion to implement good, safe locking is amazing! :-) I averse not by default. :) But I just wish understand _why_ a solution is better then other. I'm sure my solution is not the best at all, but before changing it I wish understand if the new proposal is better. > The proper way to do this is to use a kernel buffer to do all kernel-side > work (you acquire/release lock during that work) and then copy_to_user() > later, at the end. [ And something opposite for the set_xxx syscall, i.e. > first off copy_from_user() to a kernel buffer up front, before doing > anything else itself, and then do all the work in the kernel on that. ] Mmm... I think this is not easy at all for sys_time_pps_fetch(). I suppose you have to complicate its code a lot! I don't undestand why we must complicate, and made unreadable, a code in order to follow the rule use-only-one-lock-mechanism. If by using mutex and spinlocks the code is more readable, where is the fault? > BTW your syscall implementations totally lack any kind of security checks > whatsoever ... Ok, we can correct them. :) > Amazing. On the one hand, you want to use spin_trylock() in the hard irq > handler and spin_lock() (not irq safe) in the process context, because > you "don't care about losing some events". And now you want to avoid > "disabling irqs in user context to minimize possibility to delay events > recording"? Just for not delaying the IRQ handler. As already said, I prefere loosing events that delaying their timestamps recording. > Anyway, any such requirement you're talking about is just bogus, IMHO. > You're just disabling interrupts to access a data structure, for Gods' > sakes, how many nanoseconds do you imagine would you be "delaying"? As already said we noticed that just delaying of one instruction the timestamp recording the time setting degrades of about 50%. We have to take care of this point. It's _very_ important that _each_ event had its timestamp recorded with delay as small as possible. > > Please, take alook at NTPD code. Common usage is: > > > > fd = open("/dev/ttyS0", ...); > > > > pps_time_create(fd, &handler); > > > > since RFC supposes that at filedes "fd" is mapped both GPS data _and_ > > PPS source. > > Umm, I don't think the RFC supposes/assumes this anywhere. I think so. If not, why they pretend an _already opened_ filedes then just a filename to be used as parameter for the open(2) syscall? :) Again, it was simpler, and more logic, define the time_pps_create as follow: time_pps_create(char *ppsdev, pps_handle_t *handle); this definition resolves very well all possibile cases. > Of course. BTW time_pps_findpath/findsource do not have to be kernel > implemented syscalls in the first place. The best, simplest and most > straightforward place to implement them is in userspace -- the RFC > mentions this as well. Ok, I'll wait for your modification to see how you can do it. > A solution I can think of is to create a mapping at the time of > pps_register_source() between the PPS source (physically) and the special > char device. Userspace open(2)'s the special char device corresponding to > the PPS source, and then issues the time_pps_create() syscall. Here, we > lookup the mapping previously created and return handle to the PPS source > based on the special device's fd that's passed to us in time_pps_create(). Ok, just what pps_findpath&C. does... however if you now how to implement it I'll be very to see the code. :) But, as you can see, this is due the bogus RFC specification. It was more easier define the time_pps_create() as suggested above and you didn't need no mapping at all. > Ok, I'll take a look, thanks :-) > > [ what's the URL for these sources? ] Oh, yes... sorry, here the NTP main site: http://www.ntp.org > open(PPSfilename, O_RDWR) doesn't sound like that at all. If the device > for the serial port / parport was intended, it wouldn't be called > "PPSfilename", would it? No, I meant that if they require an already opened file descriptor is beacuse they simply don't suppose that a PPS source may be totally uncollerated to any device. If not they had two possibilities: 1) just using an open(2) to access a PPS source and using the returned filedes as PPS handler, 2) or, just to be more general, define the time_pps_create() as above, with the "char *ppsdevice" as parameter (then on UNIX systems we implement it with open(2)). > The physical port/device through which a PPS source is connected is > immaterial. Anyway, I'll take a look at the NTPD/userspace code you are > mentioning as well. [ again, could you point me to URL of source code? ] http://www.ntp.org/downloads.html > Sure, I'll get to implementing what I have in mind here -- will be glad > to be of any help, thanks. If you wish proving patches to LinuxPPS I just created a "develop" branch into my GIT repository: http://gitweb.enneenne.com/?p=linuxpps;a=shortlog;h=develop Please, provide patch against that branch. Thanks a lot, Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-31 8:20 ` Rodolfo Giometti @ 2007-07-31 18:49 ` Satyam Sharma 2007-07-31 19:44 ` Rodolfo Giometti 0 siblings, 1 reply; 43+ messages in thread From: Satyam Sharma @ 2007-07-31 18:49 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Tue, 31 Jul 2007, Rodolfo Giometti wrote: > On Tue, Jul 31, 2007 at 03:31:22AM +0530, Satyam Sharma wrote: > > Yup, this would avoid races, but then we will lose events. Why is that > > acceptable, when better alternative (above) exists? > > Because is better lossign events then recording them delayed. In the > past we (LinuxPPS users) noticed that just postponing of one > instruction the timestamp recording degrade the timesetting of about > 50%! > > Amazing. On the one hand, you want to use spin_trylock() in the hard irq > > handler and spin_lock() (not irq safe) in the process context, because > > you "don't care about losing some events". And now you want to avoid > > "disabling irqs in user context to minimize possibility to delay events > > recording"? > > Just for not delaying the IRQ handler. As already said, I prefere > loosing events that delaying their timestamps recording. > > Anyway, any such requirement you're talking about is just bogus, IMHO. > > You're just disabling interrupts to access a data structure, for Gods' > > sakes, how many nanoseconds do you imagine would you be "delaying"? > > As already said we noticed that just delaying of one instruction the > timestamp recording the time setting degrades of about 50%. > > We have to take care of this point. It's _very_ important that _each_ > event had its timestamp recorded with delay as small as possible. That's just absolute bullshit. I'm sorry to say this, Rodolfo, but _all_ your arguments above are *totally* nonsensical and factually incorrect -- and I have had enough of trying to talk sense to you, it's been ~15 mails in this thread already, and I've been WASTING my time trying to teach / explain to you, but it's just *shocking* that you prefer to stick to a wholly incorrect (which I suspect you've already understood by now anyway) position rather than just accepting that the present patch is wrong and go about correcting it instead. > > The proper way to do this is to use a kernel buffer to do all kernel-side > > work (you acquire/release lock during that work) and then copy_to_user() > > later, at the end. [ And something opposite for the set_xxx syscall, i.e. > > first off copy_from_user() to a kernel buffer up front, before doing > > anything else itself, and then do all the work in the kernel on that. ] > > Mmm... I think this is not easy at all for sys_time_pps_fetch(). I > suppose you have to complicate its code a lot! > > I don't undestand why we must complicate, and made unreadable, a code > in order to follow the rule use-only-one-lock-mechanism. If by using > mutex and spinlocks the code is more readable, where is the fault? More nonsense. Utter nonsense. I really don't want to reply anymore ... > > BTW your syscall implementations totally lack any kind of security checks > > whatsoever ... > > Ok, we can correct them. :) > > > > Please, take alook at NTPD code. Common usage is: > > > > > > fd = open("/dev/ttyS0", ...); > > > > > > pps_time_create(fd, &handler); > > > > > > since RFC supposes that at filedes "fd" is mapped both GPS data _and_ > > > PPS source. > > > > Umm, I don't think the RFC supposes/assumes this anywhere. > > I think so. If not, why they pretend an _already opened_ filedes then > just a filename to be used as parameter for the open(2) syscall? :) Try reading the RFC again, please. And *think*. Anyway, considering: 1. broken/nonsensical locking, 2. wrong (completely RFC non-compliant) implementation, 3. a syscall (time_pps_cmd) that has no semantics defined anywhere, not even mandated by the RFC, is (as you yourself admitted) a pseudo-ioctl for all practical purposes, 4. abject lack of security in the syscall implementations, But MOST importantly: 5. your _sticking_ to the broken implementation and being so (shockingly!) unwilling to correct these, I really cannot see how I can support this stuff in getting merged at all, sorry. Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-31 18:49 ` Satyam Sharma @ 2007-07-31 19:44 ` Rodolfo Giometti 2007-07-31 21:15 ` Satyam Sharma 0 siblings, 1 reply; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-31 19:44 UTC (permalink / raw) To: Satyam Sharma; +Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton On Wed, Aug 01, 2007 at 12:19:48AM +0530, Satyam Sharma wrote: > That's just absolute bullshit. ... > I'm sorry to say this, Rodolfo, but _all_ your arguments above are > *totally* nonsensical and factually incorrect -- and I have had enough of > trying to talk sense to you, it's been ~15 mails in this thread already, > and I've been WASTING my time trying to teach / explain to you, but it's > just *shocking* that you prefer to stick to a wholly incorrect (which I > suspect you've already understood by now anyway) position rather than > just accepting that the present patch is wrong and go about correcting > it instead. > [snip] Sorry for wasting your time. :'( Maybe you can provide your solution for PPS support and get it included into kernel tree so we can use it and live happy! :) Several people (Andrew, David, et all) wrote to me a lot of letters without loosing their patience. I'm a poor programmer, not a «guru» like you, and I need more time to understand things. I'm trying to do my best. :) However I'm very proud to be a "poor programmer" (slow in understanding things) but a gentleman rather than a "kernel-guru" like you but totally ill-mannered. Thanks anyway for your (precious) time, Rodolfo P.S. A gentle programmer just wrote to me a letter where, proposing code/patches, showed to me possible good solutions, so I think I'm going to modify again the locking code soon. -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: LinuxPPS & spinlocks 2007-07-31 19:44 ` Rodolfo Giometti @ 2007-07-31 21:15 ` Satyam Sharma 0 siblings, 0 replies; 43+ messages in thread From: Satyam Sharma @ 2007-07-31 21:15 UTC (permalink / raw) To: Rodolfo Giometti Cc: Chris Friesen, David Woodhouse, linux-kernel, Andrew Morton Hi, On Tue, 31 Jul 2007, Rodolfo Giometti wrote: > Sorry for wasting your time. :'( Maybe you can provide your solution > for PPS support and get it included into kernel tree so we can use it > and live happy! :) Please stop embarrassing me (and yourself). Sorry, I did lose my patience (others you mention did not) but then that's precisely because of my own _less_ experience, if anything. No, it's not like I "want to provide my solution for PPS support and get it included into kernel tree" like you wrote above -- I simply identified 4 problem areas in your implementation and wanted them to be addressed. [If you can do so yourself, good enough, otherwise I'm happy to send patch based on your earlier one too -- the modifications I have in mind are few and simple.] I have no personal stake in this PPS stuff anyway, this is just a normal peer review of submissions that should always happen. Thanks, Satyam ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 13:49 ` David Woodhouse 2007-07-24 14:20 ` Rodolfo Giometti @ 2007-07-24 14:31 ` Rodolfo Giometti 2007-07-24 14:45 ` David Woodhouse 2007-07-26 19:52 ` Roman Zippel 1 sibling, 2 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-24 14:31 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton On Tue, Jul 24, 2007 at 02:49:02PM +0100, David Woodhouse wrote: > > I think you still haven't quite got the 32-bit vs. 64-bit compatibility > right. Remember that on i386, the alignment of a uint64_t is only 4 > bytes, while on most other architectures it's 8 bytes. On i386, there > will be no padding between the two consecutive 'struct pps_ktime' > members of struct pps_kinfo and struct pps_kparams. But on most > platforms there will be padding to ensure correct alignment. > > The simple fix is probably to make the 'nsec' member a 64-bit integer > too. Then it'll be the same for i386 and x86_64 and you won't need a > compatibility syscall routine. By doing: struct pps_ktime { __u64 sec; - __u32 nsec; + __u64 nsec; }; I got: GEN .version CHK include/linux/compile.h UPD include/linux/compile.h CC init/version.o LD init/built-in.o LD .tmp_vmlinux1 drivers/built-in.o: In function `sys_time_pps_fetch': (.text+0x5f05e): undefined reference to `__udivdi3' make: *** [.tmp_vmlinux1] Error 1 I suppose the problem is here: ticks = to.sec * HZ; ticks += to.nsec / (NSEC_PER_SEC / HZ); Suggestions? :) Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti @ 2007-07-24 14:45 ` David Woodhouse 2007-07-24 16:09 ` Rodolfo Giometti 2007-07-26 19:52 ` Roman Zippel 1 sibling, 1 reply; 43+ messages in thread From: David Woodhouse @ 2007-07-24 14:45 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: linux-kernel, Andrew Morton On Tue, 2007-07-24 at 16:31 +0200, Rodolfo Giometti wrote: > drivers/built-in.o: In function `sys_time_pps_fetch': > (.text+0x5f05e): undefined reference to `__udivdi3' Hm, not sure. Maybe put it back to uint32_t and then add another uint32_t of explicit padding, or maybe just cast it to uint32_t when you divide: ticks += (uint32_t)to.nsec / (NSEC_PER_SEC/HZ); -- dwmw2 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:45 ` David Woodhouse @ 2007-07-24 16:09 ` Rodolfo Giometti 0 siblings, 0 replies; 43+ messages in thread From: Rodolfo Giometti @ 2007-07-24 16:09 UTC (permalink / raw) To: David Woodhouse; +Cc: linux-kernel, Andrew Morton On Tue, Jul 24, 2007 at 03:45:19PM +0100, David Woodhouse wrote: > On Tue, 2007-07-24 at 16:31 +0200, Rodolfo Giometti wrote: > > drivers/built-in.o: In function `sys_time_pps_fetch': > > (.text+0x5f05e): undefined reference to `__udivdi3' > > Hm, not sure. Maybe put it back to uint32_t and then add another > uint32_t of explicit padding, or maybe just cast it to uint32_t when you > divide: > > ticks += (uint32_t)to.nsec / (NSEC_PER_SEC/HZ); Ok, padding data added. :) Rodolfo -- GNU/Linux Solutions e-mail: giometti@enneenne.com Linux Device Driver giometti@gnudd.com Embedded Systems giometti@linux.it UNIX programming phone: +39 349 2432127 ^ permalink raw reply [flat|nested] 43+ messages in thread
* Re: [PATCH] LinuxPPS - definitive version 2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti 2007-07-24 14:45 ` David Woodhouse @ 2007-07-26 19:52 ` Roman Zippel 1 sibling, 0 replies; 43+ messages in thread From: Roman Zippel @ 2007-07-26 19:52 UTC (permalink / raw) To: Rodolfo Giometti; +Cc: David Woodhouse, linux-kernel, Andrew Morton Hi, On Tuesday 24 July 2007, Rodolfo Giometti wrote: > By doing: > > struct pps_ktime { > __u64 sec; > - __u32 nsec; > + __u64 nsec; > }; Just using __u32 for both works as well... bye, Roman ^ permalink raw reply [flat|nested] 43+ messages in thread
end of thread, other threads:[~2007-08-01 22:51 UTC | newest] Thread overview: 43+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2007-07-17 18:05 [PATCH] LinuxPPS - definitive version Rodolfo Giometti 2007-07-23 13:35 ` David Woodhouse 2007-07-23 16:04 ` Rodolfo Giometti 2007-07-23 19:28 ` Andrew Morton 2007-07-23 19:48 ` David Woodhouse 2007-07-24 8:00 ` Rodolfo Giometti 2007-07-24 13:49 ` David Woodhouse 2007-07-24 14:20 ` Rodolfo Giometti 2007-07-24 14:46 ` David Woodhouse 2007-07-24 14:52 ` David Woodhouse 2007-07-24 16:01 ` Rodolfo Giometti 2007-07-27 18:44 ` LinuxPPS & spinlocks Rodolfo Giometti 2007-07-27 19:08 ` Chris Friesen 2007-07-27 19:28 ` Rodolfo Giometti 2007-07-27 19:40 ` Chris Friesen 2007-07-27 19:45 ` Rodolfo Giometti 2007-07-27 20:47 ` Satyam Sharma 2007-07-27 23:41 ` Satyam Sharma 2007-07-29 9:50 ` Rodolfo Giometti 2007-07-30 5:03 ` Satyam Sharma 2007-07-30 8:51 ` Rodolfo Giometti 2007-07-30 9:20 ` Satyam Sharma 2007-08-01 22:14 ` Christopher Hoover 2007-08-01 23:03 ` Satyam Sharma 2007-07-29 9:57 ` Rodolfo Giometti 2007-07-29 10:00 ` Rodolfo Giometti 2007-07-30 5:09 ` Satyam Sharma 2007-07-30 8:53 ` Rodolfo Giometti 2007-07-30 9:31 ` Satyam Sharma 2007-07-29 9:17 ` Rodolfo Giometti 2007-07-30 4:19 ` Satyam Sharma 2007-07-30 8:32 ` Rodolfo Giometti 2007-07-30 9:07 ` Satyam Sharma 2007-07-30 14:55 ` Rodolfo Giometti 2007-07-30 22:01 ` Satyam Sharma 2007-07-31 8:20 ` Rodolfo Giometti 2007-07-31 18:49 ` Satyam Sharma 2007-07-31 19:44 ` Rodolfo Giometti 2007-07-31 21:15 ` Satyam Sharma 2007-07-24 14:31 ` [PATCH] LinuxPPS - definitive version Rodolfo Giometti 2007-07-24 14:45 ` David Woodhouse 2007-07-24 16:09 ` Rodolfo Giometti 2007-07-26 19:52 ` Roman Zippel
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox