projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
This Patch adds PPS (Pulse per Second) Support to Openwrt 2.6.23 (its deprecated...
[openwrt/openwrt.git] / target / linux / generic-2.6 / patches-2.6.23 / 230-pps_support.patch
1 diff --git a/Documentation/pps/Makefile b/Documentation/pps/Makefile
2 new file mode 100644
3 index 0000000..a2660a2
4 --- /dev/null
5 +++ b/Documentation/pps/Makefile
6 @@ -0,0 +1,27 @@
7 +TARGETS = ppstest ppsctl
8 +
9 +CFLAGS += -Wall -O2 -D_GNU_SOURCE
10 +CFLAGS += -I .
11 +CFLAGS += -ggdb
12 +
13 +# -- Actions section ----------------------------------------------------------
14 +
15 +.PHONY : all depend dep
16 +
17 +all : .depend $(TARGETS)
18 +
19 +.depend depend dep :
20 + $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend
21 +
22 +ifeq (.depend,$(wildcard .depend))
23 +include .depend
24 +endif
25 +
26 +
27 +# -- Clean section ------------------------------------------------------------
28 +
29 +.PHONY : clean
30 +
31 +clean :
32 + rm -f *.o *~ core .depend
33 + rm -f ${TARGETS}
34 diff --git a/Documentation/pps/pps.txt b/Documentation/pps/pps.txt
35 new file mode 100644
36 index 0000000..9538925
37 --- /dev/null
38 +++ b/Documentation/pps/pps.txt
39 @@ -0,0 +1,170 @@
40 +
41 + PPS - Pulse Per Second
42 + ----------------------
43 +
44 +(C) Copyright 2007 Rodolfo Giometti <giometti@enneenne.com>
45 +
46 +This program is free software; you can redistribute it and/or modify
47 +it under the terms of the GNU General Public License as published by
48 +the Free Software Foundation; either version 2 of the License, or
49 +(at your option) any later version.
50 +
51 +This program is distributed in the hope that it will be useful,
52 +but WITHOUT ANY WARRANTY; without even the implied warranty of
53 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
54 +GNU General Public License for more details.
55 +
56 +
57 +
58 +Overview
59 +--------
60 +
61 +LinuxPPS provides a programming interface (API) to define into the
62 +system several PPS sources.
63 +
64 +PPS means "pulse per second" and a PPS source is just a device which
65 +provides a high precision signal each second so that an application
66 +can use it to adjust system clock time.
67 +
68 +A PPS source can be connected to a serial port (usually to the Data
69 +Carrier Detect pin) or to a parallel port (ACK-pin) or to a special
70 +CPU's GPIOs (this is the common case in embedded systems) but in each
71 +case when a new pulse comes the system must apply to it a timestamp
72 +and record it for the userland.
73 +
74 +Common use is the combination of the NTPD as userland program with a
75 +GPS receiver as PPS source to obtain a wallclock-time with
76 +sub-millisecond synchronisation to UTC.
77 +
78 +
79 +RFC considerations
80 +------------------
81 +
82 +While implementing a PPS API as RFC 2783 defines and using an embedded
83 +CPU GPIO-Pin as physical link to the signal, I encountered a deeper
84 +problem:
85 +
86 + At startup it needs a file descriptor as argument for the function
87 + time_pps_create().
88 +
89 +This implies that the source has a /dev/... entry. This assumption is
90 +ok for the serial and parallel port, where you can do something
91 +useful besides(!) the gathering of timestamps as it is the central
92 +task for a PPS-API. But this assumption does not work for a single
93 +purpose GPIO line. In this case even basic file-related functionality
94 +(like read() and write()) makes no sense at all and should not be a
95 +precondition for the use of a PPS-API.
96 +
97 +The problem can be simply solved if you consider that a PPS source is
98 +not always connected with a GPS data source.
99 +
100 +So your programs should check if the GPS data source (the serial port
101 +for instance) is a PPS source too, otherwise they should provide the
102 +possibility to open another device as PPS source.
103 +
104 +In LinuxPPS the PPS sources are simply char devices usually mapped
105 +into files /dev/pps0, /dev/pps1, etc..
106 +
107 +
108 +Coding example
109 +--------------
110 +
111 +To register a PPS source into the kernel you should define a struct
112 +pps_source_info_s as follow:
113 +
114 + static struct pps_source_info_s pps_ktimer_info = {
115 + name : "ktimer",
116 + path : "",
117 + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
118 + PPS_ECHOASSERT | \
119 + PPS_CANWAIT | PPS_TSFMT_TSPEC,
120 + echo : pps_ktimer_echo,
121 + owner : THIS_MODULE,
122 + };
123 +
124 +and then calling the function pps_register_source() in your
125 +intialization routine as follow:
126 +
127 + source = pps_register_source(&pps_ktimer_info,
128 + PPS_CAPTUREASSERT | PPS_OFFSETASSERT);
129 +
130 +The pps_register_source() prototype is:
131 +
132 + int pps_register_source(struct pps_source_info_s *info, int default_params)
133 +
134 +where "info" is a pointer to a structure that describes a particular
135 +PPS source, "default_params" tells the system what the initial default
136 +parameters for the device should be (is obvious that these parameters
137 +must be a subset of ones defined into the struct
138 +pps_source_info_s which describe the capabilities of the driver).
139 +
140 +Once you have registered a new PPS source into the system you can
141 +signal an assert event (for example in the interrupt handler routine)
142 +just using:
143 +
144 + pps_event(source, PPS_CAPTUREASSERT, ptr);
145 +
146 +The same function may also run the defined echo function
147 +(pps_ktimer_echo(), passing to it the "ptr" pointer) if the user
148 +asked for that... etc..
149 +
150 +Please see the file drivers/pps/clients/ktimer.c for an example code.
151 +
152 +
153 +SYSFS support
154 +-------------
155 +
156 +If the SYSFS filesystem is enabled in the kernel it provides a new class:
157 +
158 + $ ls /sys/class/pps/
159 + pps0/ pps1/ pps2/
160 +
161 +Every directory is the ID of a PPS sources defined into the system and
162 +inside you find several files:
163 +
164 + $ ls /sys/class/pps/pps0/
165 + assert clear echo mode name path subsystem@ uevent
166 +
167 +Inside each "assert" and "clear" file you can find the timestamp and a
168 +sequence number:
169 +
170 + $ cat /sys/class/pps/pps0/assert
171 + 1170026870.983207967#8
172 +
173 +Where before the "#" is the timestamp in seconds and after it is the
174 +sequence number. Other files are:
175 +
176 +* echo: reports if the PPS source has an echo function or not;
177 +
178 +* mode: reports available PPS functioning modes;
179 +
180 +* name: reports the PPS source's name;
181 +
182 +* path: reports the PPS source's device path, that is the device the
183 + PPS source is connected to (if it exists).
184 +
185 +
186 +Testing the PPS support
187 +-----------------------
188 +
189 +In order to test the PPS support even without specific hardware you can use
190 +the ktimer driver (see the client subsection in the PPS configuration menu)
191 +and the userland tools provided into Documentaion/pps/ directory.
192 +
193 +Once you have enabled the compilation of ktimer just modprobe it (if
194 +not statically compiled):
195 +
196 + # modprobe ktimer
197 +
198 +and the run ppstest as follow:
199 +
200 + $ ./ppstest /dev/pps0
201 + trying PPS source "/dev/pps1"
202 + found PPS source "/dev/pps1"
203 + ok, found 1 source(s), now start fetching data...
204 + source 0 - assert 1186592699.388832443, sequence: 364 - clear 0.000000000, sequence: 0
205 + source 0 - assert 1186592700.388931295, sequence: 365 - clear 0.000000000, sequence: 0
206 + source 0 - assert 1186592701.389032765, sequence: 366 - clear 0.000000000, sequence: 0
207 +
208 +Please, note that to compile userland programs you need the file timepps.h
209 +(see Documentation/pps/).
210 diff --git a/Documentation/pps/ppsctl.c b/Documentation/pps/ppsctl.c
211 new file mode 100644
212 index 0000000..83fd08a
213 --- /dev/null
214 +++ b/Documentation/pps/ppsctl.c
215 @@ -0,0 +1,62 @@
216 +#include <stdio.h>
217 +#include <unistd.h>
218 +#include <stdlib.h>
219 +#include <errno.h>
220 +#include <sys/ioctl.h>
221 +#include <sys/types.h>
222 +#include <sys/stat.h>
223 +#include <fcntl.h>
224 +#include <string.h>
225 +#include <linux/serial.h>
226 +
227 +void usage(char *name)
228 +{
229 + fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);
230 +
231 + exit(EXIT_FAILURE);
232 +}
233 +
234 +int main(int argc, char *argv[])
235 +{
236 + int fd;
237 + int ret;
238 + struct serial_struct ss;
239 +
240 + if (argc < 2)
241 + usage(argv[0]);
242 +
243 + fd = open(argv[1], O_RDWR);
244 + if (fd < 0) {
245 + perror("open");
246 + exit(EXIT_FAILURE);
247 + }
248 +
249 + ret = ioctl(fd, TIOCGSERIAL, &ss);
250 + if (ret < 0) {
251 + perror("ioctl(TIOCGSERIAL)");
252 + exit(EXIT_FAILURE);
253 + }
254 +
255 + if (argc < 3) { /* just read PPS status */
256 + printf("PPS is %sabled\n",
257 + ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");
258 + exit(EXIT_SUCCESS);
259 + }
260 +
261 + if (argv[2][0] == 'e' || argv[2][0] == '1')
262 + ss.flags |= ASYNC_HARDPPS_CD;
263 + else if (argv[2][0] == 'd' || argv[2][0] == '0')
264 + ss.flags &= ~ASYNC_HARDPPS_CD;
265 + else {
266 + fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);
267 + exit(EXIT_FAILURE);
268 + }
269 +
270 + ret = ioctl(fd, TIOCSSERIAL, &ss);
271 + if (ret < 0) {
272 + perror("ioctl(TIOCSSERIAL)");
273 + exit(EXIT_FAILURE);
274 + }
275 +
276 + return 0;
277 +}
278 diff --git a/Documentation/pps/ppsfind b/Documentation/pps/ppsfind
279 new file mode 100755
280 index 0000000..93c0e17
281 --- /dev/null
282 +++ b/Documentation/pps/ppsfind
283 @@ -0,0 +1,17 @@
284 +#!/bin/sh
285 +
286 +SYS="/sys/class/pps/"
287 +
288 +if [ $# -lt 1 ] ; then
289 + echo "usage: ppsfind <name>" >&2
290 + exit 1
291 +fi
292 +
293 +for d in $(ls $SYS) ; do
294 + if grep $1 $SYS/$d/name >& /dev/null || \
295 + grep $1 $SYS/$d/path >& /dev/null ; then
296 + echo "$d: name=$(cat $SYS/$d/name) path=$(cat $SYS/$d/path)"
297 + fi
298 +done
299 +
300 +exit 0
301 diff --git a/Documentation/pps/ppstest.c b/Documentation/pps/ppstest.c
302 new file mode 100644
303 index 0000000..d125ffa
304 --- /dev/null
305 +++ b/Documentation/pps/ppstest.c
306 @@ -0,0 +1,151 @@
307 +#include <stdio.h>
308 +#include <stdlib.h>
309 +#include <unistd.h>
310 +#include <errno.h>
311 +#include <string.h>
312 +#include <sys/types.h>
313 +#include <sys/stat.h>
314 +#include <fcntl.h>
315 +
316 +#include <timepps.h>
317 +
318 +int find_source(char *path, pps_handle_t *handle, int *avail_mode)
319 +{
320 + pps_params_t params;
321 + int ret;
322 +
323 + printf("trying PPS source \"%s\"\n", path);
324 +
325 + /* Try to find the source by using the supplied "path" name */
326 + ret = open(path, O_RDWR);
327 + if (ret < 0) {
328 + fprintf(stderr, "unable to open device \"%s\" (%m)\n", path);
329 + return ret;
330 + }
331 +
332 + /* Open the PPS source (and check the file descriptor) */
333 + ret = time_pps_create(ret, handle);
334 + if (ret < 0) {
335 + fprintf(stderr, "cannot create a PPS source from device "
336 + "\"%s\" (%m)\n", path);
337 + return -1;
338 + }
339 + printf("found PPS source \"%s\"\n", path);
340 +
341 + /* Find out what features are supported */
342 + ret = time_pps_getcap(*handle, avail_mode);
343 + if (ret < 0) {
344 + fprintf(stderr, "cannot get capabilities (%m)\n");
345 + return -1;
346 + }
347 + if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {
348 + fprintf(stderr, "cannot CAPTUREASSERT\n");
349 + return -1;
350 + }
351 + if ((*avail_mode & PPS_OFFSETASSERT) == 0) {
352 + fprintf(stderr, "cannot OFFSETASSERT\n");
353 + return -1;
354 + }
355 +
356 + /* Capture assert timestamps, and compensate for a 675 nsec
357 + * propagation delay */
358 + ret = time_pps_getparams(*handle, &params);
359 + if (ret < 0) {
360 + fprintf(stderr, "cannot get parameters (%m)\n");
361 + return -1;
362 + }
363 + params.assert_offset.tv_sec = 0;
364 + params.assert_offset.tv_nsec = 675;
365 + params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT;
366 + ret = time_pps_setparams(*handle, &params);
367 + if (ret < 0) {
368 + fprintf(stderr, "cannot set parameters (%m)\n");
369 + return -1;
370 + }
371 +
372 + return 0;
373 +}
374 +
375 +int fetch_source(int i, pps_handle_t *handle, int *avail_mode)
376 +{
377 + struct timespec timeout;
378 + pps_info_t infobuf;
379 + int ret;
380 +
381 + /* create a zero-valued timeout */
382 + timeout.tv_sec = 3;
383 + timeout.tv_nsec = 0;
384 +
385 +retry:
386 + if (*avail_mode & PPS_CANWAIT) /* waits for the next event */
387 + ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
388 + &timeout);
389 + else {
390 + sleep(1);
391 + ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,
392 + &timeout);
393 + }
394 + if (ret < 0) {
395 + if (ret == -EINTR) {
396 + fprintf(stderr, "time_pps_fetch() got a signal!\n");
397 + goto retry;
398 + }
399 +
400 + fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);
401 + return -1;
402 + }
403 +
404 + printf("source %d - "
405 + "assert %ld.%09ld, sequence: %ld - "
406 + "clear %ld.%09ld, sequence: %ld\n",
407 + i,
408 + infobuf.assert_timestamp.tv_sec,
409 + infobuf.assert_timestamp.tv_nsec,
410 + infobuf.assert_sequence,
411 + infobuf.clear_timestamp.tv_sec,
412 + infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence);
413 +
414 + return 0;
415 +}
416 +
417 +void usage(char *name)
418 +{
419 + fprintf(stderr, "usage: %s <ppsdev> [<ppsdev> ...]\n", name);
420 + exit(EXIT_FAILURE);
421 +}
422 +
423 +int main(int argc, char *argv[])
424 +{
425 + int num;
426 + pps_handle_t handle[4];
427 + int avail_mode[4];
428 + int i = 0;
429 + int ret;
430 +
431 + /* Check the command line */
432 + if (argc < 2)
433 + usage(argv[0]);
434 +
435 + for (i = 1; i < argc && i <= 4; i++) {
436 + ret = find_source(argv[i], &handle[i - 1], &avail_mode[i - 1]);
437 + if (ret < 0)
438 + exit(EXIT_FAILURE);
439 + }
440 +
441 + num = i - 1;
442 + printf("ok, found %d source(s), now start fetching data...\n", num);
443 +
444 + /* loop, printing the most recent timestamp every second or so */
445 + while (1) {
446 + for (i = 0; i < num; i++) {
447 + ret = fetch_source(i, &handle[i], &avail_mode[i]);
448 + if (ret < 0 && errno != ETIMEDOUT)
449 + exit(EXIT_FAILURE);
450 + }
451 + }
452 +
453 + for (; i >= 0; i--)
454 + time_pps_destroy(handle[i]);
455 +
456 + return 0;
457 +}
458 diff --git a/Documentation/pps/timepps.h b/Documentation/pps/timepps.h
459 new file mode 100644
460 index 0000000..28ebf4c
461 --- /dev/null
462 +++ b/Documentation/pps/timepps.h
463 @@ -0,0 +1,193 @@
464 +/*
465 + * timepps.h -- PPS API main header
466 + *
467 + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
468 + *
469 + * This program is free software; you can redistribute it and/or modify
470 + * it under the terms of the GNU General Public License as published by
471 + * the Free Software Foundation; either version 2 of the License, or
472 + * (at your option) any later version.
473 + *
474 + * This program is distributed in the hope that it will be useful,
475 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
476 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
477 + * GNU General Public License for more details.
478 + *
479 + * You should have received a copy of the GNU General Public License
480 + * along with this program; if not, write to the Free Software
481 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
482 + */
483 +
484 +#ifndef _SYS_TIMEPPS_H_
485 +#define _SYS_TIMEPPS_H_
486 +
487 +#include <sys/syscall.h>
488 +#include <unistd.h>
489 +#include <errno.h>
490 +#include <linux/pps.h>
491 +
492 +/*
493 + * New data structures
494 + */
495 +
496 +struct ntp_fp {
497 + unsigned int integral;
498 + unsigned int fractional;
499 +};
500 +
501 +union pps_timeu {
502 + struct timespec tspec;
503 + struct ntp_fp ntpfp;
504 + unsigned long longpad[3];
505 +};
506 +
507 +struct pps_info {
508 + unsigned long assert_sequence; /* seq. num. of assert event */
509 + unsigned long clear_sequence; /* seq. num. of clear event */
510 + union pps_timeu assert_tu; /* time of assert event */
511 + union pps_timeu clear_tu; /* time of clear event */
512 + int current_mode; /* current mode bits */
513 +};
514 +
515 +struct pps_params {
516 + int api_version; /* API version # */
517 + int mode; /* mode bits */
518 + union pps_timeu assert_off_tu; /* offset compensation for assert */
519 + union pps_timeu clear_off_tu; /* offset compensation for clear */
520 +};
521 +
522 +typedef int pps_handle_t; /* represents a PPS source */
523 +typedef unsigned long pps_seq_t; /* sequence number */
524 +typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */
525 +typedef union pps_timeu pps_timeu_t; /* generic data type for time stamps */
526 +typedef struct pps_info pps_info_t;
527 +typedef struct pps_params pps_params_t;
528 +
529 +#define assert_timestamp assert_tu.tspec
530 +#define clear_timestamp clear_tu.tspec
531 +
532 +#define assert_timestamp_ntpfp assert_tu.ntpfp
533 +#define clear_timestamp_ntpfp clear_tu.ntpfp
534 +
535 +#define assert_offset assert_off_tu.tspec
536 +#define clear_offset clear_off_tu.tspec
537 +
538 +#define assert_offset_ntpfp assert_off_tu.ntpfp
539 +#define clear_offset_ntpfp clear_off_tu.ntpfp
540 +
541 +/*
542 + * The PPS API
543 + */
544 +
545 +static __inline int time_pps_create(int source, pps_handle_t *handle)
546 +{
547 + int ret;
548 +
549 + if (!handle) {
550 + errno = EINVAL;
551 + return -1;
552 + }
553 +
554 + /* First we check if current device is a PPS valid PPS one...
555 + */
556 + ret = ioctl(source, PPS_CHECK);
557 + if (ret) {
558 + errno = EOPNOTSUPP;
559 + return -1;
560 + }
561 +
562 + /* ... then since in LinuxPPS there are no differences between a
563 + * "PPS source" and a "PPS handle", we simply return the same value.
564 + */
565 + *handle = source;
566 +
567 + return 0;
568 +}
569 +
570 +static __inline int time_pps_destroy(pps_handle_t handle)
571 +{
572 + return close(handle);
573 +}
574 +
575 +static __inline int time_pps_getparams(pps_handle_t handle,
576 + pps_params_t *ppsparams)
577 +{
578 + int ret;
579 + struct pps_kparams __ppsparams;
580 +
581 + ret = ioctl(handle, PPS_GETPARAMS, &__ppsparams);
582 +
583 + ppsparams->api_version = __ppsparams.api_version;
584 + ppsparams->mode = __ppsparams.mode;
585 + ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;
586 + ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;
587 + ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;
588 + ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;
589 +
590 + return ret;
591 +}
592 +
593 +static __inline int time_pps_setparams(pps_handle_t handle,
594 + const pps_params_t *ppsparams)
595 +{
596 + struct pps_kparams __ppsparams;
597 +
598 + __ppsparams.api_version = ppsparams->api_version;
599 + __ppsparams.mode = ppsparams->mode;
600 + __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;
601 + __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;
602 + __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;
603 + __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;
604 +
605 + return ioctl(handle, PPS_SETPARAMS, &__ppsparams);
606 +}
607 +
608 +/* Get capabilities for handle */
609 +static __inline int time_pps_getcap(pps_handle_t handle, int *mode)
610 +{
611 + return ioctl(handle, PPS_GETCAP, mode);
612 +}
613 +
614 +static __inline int time_pps_fetch(pps_handle_t handle, const int tsformat,
615 + pps_info_t *ppsinfobuf,
616 + const struct timespec *timeout)
617 +{
618 + struct pps_fdata __fdata;
619 + int ret;
620 +
621 + /* Sanity checks */
622 + if (tsformat != PPS_TSFMT_TSPEC) {
623 + errno = EINVAL;
624 + return -1;
625 + }
626 +
627 + if (timeout) {
628 + __fdata.timeout.sec = timeout->tv_sec;
629 + __fdata.timeout.nsec = timeout->tv_nsec;
630 + __fdata.timeout.flags = ~PPS_TIME_INVALID;
631 + } else
632 + __fdata.timeout.flags = PPS_TIME_INVALID;
633 +
634 + ret = ioctl(handle, PPS_FETCH, &__fdata);
635 +
636 + ppsinfobuf->assert_sequence = __fdata.info.assert_sequence;
637 + ppsinfobuf->clear_sequence = __fdata.info.clear_sequence;
638 + ppsinfobuf->assert_tu.tspec.tv_sec = __fdata.info.assert_tu.sec;
639 + ppsinfobuf->assert_tu.tspec.tv_nsec = __fdata.info.assert_tu.nsec;
640 + ppsinfobuf->clear_tu.tspec.tv_sec = __fdata.info.clear_tu.sec;
641 + ppsinfobuf->clear_tu.tspec.tv_nsec = __fdata.info.clear_tu.nsec;
642 + ppsinfobuf->current_mode = __fdata.info.current_mode;
643 +
644 + return ret;
645 +}
646 +
647 +static __inline int time_pps_kcbind(pps_handle_t handle,
648 + const int kernel_consumer,
649 + const int edge, const int tsformat)
650 +{
651 + /* LinuxPPS doesn't implement kernel consumer feature */
652 + errno = EOPNOTSUPP;
653 + return -1;
654 +}
655 +
656 +#endif /* _SYS_TIMEPPS_H_ */
657 diff --git a/MAINTAINERS b/MAINTAINERS
658 index 9a91d9e..f45e974 100644
659 --- a/MAINTAINERS
660 +++ b/MAINTAINERS
661 @@ -3011,6 +3011,13 @@ P: James Chapman
662 M: jchapman@katalix.com
663 S: Maintained
664
665 +PPS SUPPORT
666 +P: Rodolfo Giometti
667 +M: giometti@enneenne.com
668 +W: http://wiki.enneenne.com/index.php/LinuxPPS_support
669 +L: linuxpps@ml.enneenne.com
670 +S: Maintained
671 +
672 PREEMPTIBLE KERNEL
673 P: Robert Love
674 M: rml@tech9.net
675 diff --git a/drivers/Kconfig b/drivers/Kconfig
676 index 3e1c442..bffc48e 100644
677 --- a/drivers/Kconfig
678 +++ b/drivers/Kconfig
679 @@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
680
681 source "drivers/spi/Kconfig"
682
683 +source "drivers/pps/Kconfig"
684 +
685 source "drivers/w1/Kconfig"
686
687 source "drivers/power/Kconfig"
688 diff --git a/drivers/Makefile b/drivers/Makefile
689 index f0878b2..2e84e49 100644
690 --- a/drivers/Makefile
691 +++ b/drivers/Makefile
692 @@ -63,6 +63,7 @@ obj-$(CONFIG_INPUT) += input/
693 obj-$(CONFIG_I2O) += message/
694 obj-$(CONFIG_RTC_LIB) += rtc/
695 obj-y += i2c/
696 +obj-$(CONFIG_PPS) += pps/
697 obj-$(CONFIG_W1) += w1/
698 obj-$(CONFIG_POWER_SUPPLY) += power/
699 obj-$(CONFIG_HWMON) += hwmon/
700 diff --git a/drivers/char/lp.c b/drivers/char/lp.c
701 index 62051f8..e0a8364 100644
702 --- a/drivers/char/lp.c
703 +++ b/drivers/char/lp.c
704 @@ -746,6 +746,27 @@ static struct console lpcons = {
705
706 #endif /* console on line printer */
707
708 +/* Support for PPS signal on the line printer */
709 +
710 +#ifdef CONFIG_PPS_CLIENT_LP
711 +
712 +static void lp_pps_echo(int source, int event, void *data)
713 +{
714 + struct parport *port = data;
715 + unsigned char status = parport_read_status(port);
716 +
717 + /* echo event via SEL bit */
718 + parport_write_control(port,
719 + parport_read_control(port) | PARPORT_CONTROL_SELECT);
720 +
721 + /* signal no event */
722 + if ((status & PARPORT_STATUS_ACK) != 0)
723 + parport_write_control(port,
724 + parport_read_control(port) & ~PARPORT_CONTROL_SELECT);
725 +}
726 +
727 +#endif
728 +
729 /* --- initialisation code ------------------------------------- */
730
731 static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
732 @@ -817,6 +838,38 @@ static int lp_register(int nr, struct parport *port)
733 }
734 #endif
735
736 +#ifdef CONFIG_PPS_CLIENT_LP
737 + port->pps_info.owner = THIS_MODULE;
738 + port->pps_info.dev = port->dev;
739 + snprintf(port->pps_info.path, PPS_MAX_NAME_LEN, "/dev/lp%d", nr);
740 +
741 + /* No PPS support if lp port has no IRQ line */
742 + if (port->irq != PARPORT_IRQ_NONE) {
743 + strncpy(port->pps_info.name, port->name, PPS_MAX_NAME_LEN);
744 +
745 + port->pps_info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
746 + PPS_ECHOASSERT | \
747 + PPS_CANWAIT | PPS_TSFMT_TSPEC;
748 +
749 + port->pps_info.echo = lp_pps_echo;
750 +
751 + port->pps_source = pps_register_source(&(port->pps_info),
752 + PPS_CAPTUREASSERT | PPS_OFFSETASSERT);
753 + if (port->pps_source < 0)
754 + dev_err(port->dev,
755 + "cannot register PPS source \"%s\"\n",
756 + port->pps_info.path);
757 + else
758 + dev_info(port->dev, "PPS source #%d \"%s\" added\n",
759 + port->pps_source, port->pps_info.path);
760 + } else {
761 + port->pps_source = -1;
762 + dev_err(port->dev, "PPS support disabled due port \"%s\" is "
763 + "in polling mode\n",
764 + port->pps_info.path);
765 + }
766 +#endif
767 +
768 return 0;
769 }
770
771 @@ -860,6 +913,14 @@ static void lp_detach (struct parport *port)
772 console_registered = NULL;
773 }
774 #endif /* CONFIG_LP_CONSOLE */
775 +
776 +#ifdef CONFIG_PPS_CLIENT_LP
777 + if (port->pps_source >= 0) {
778 + pps_unregister_source(port->pps_source);
779 + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n",
780 + port->pps_source, port->pps_info.path);
781 + }
782 +#endif
783 }
784
785 static struct parport_driver lp_driver = {
786 diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
787 new file mode 100644
788 index 0000000..bfe6621
789 --- /dev/null
790 +++ b/drivers/pps/Kconfig
791 @@ -0,0 +1,34 @@
792 +#
793 +# PPS support configuration
794 +#
795 +
796 +menu "PPS support"
797 +
798 +config PPS
799 + tristate "PPS support"
800 + depends on EXPERIMENTAL
801 + ---help---
802 + PPS (Pulse Per Second) is a special pulse provided by some GPS
803 + antennae. Userland can use it to get an high time reference.
804 +
805 + Some antennae's PPS signals are connected with the CD (Carrier
806 + Detect) pin of the serial line they use to communicate with the
807 + host. In this case use the SERIAL_LINE client support.
808 +
809 + Some antennae's PPS signals are connected with some special host
810 + inputs so you have to enable the corresponding client support.
811 +
812 + To compile this driver as a module, choose M here: the module
813 + will be called pps_core.ko.
814 +
815 +config PPS_DEBUG
816 + bool "PPS debugging messages"
817 + depends on PPS
818 + help
819 + Say Y here if you want the PPS support to produce a bunch of debug
820 + messages to the system log. Select this if you are having a
821 + problem with PPS support and want to see more of what is going on.
822 +
823 +source drivers/pps/clients/Kconfig
824 +
825 +endmenu
826 diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
827 new file mode 100644
828 index 0000000..d8ec308
829 --- /dev/null
830 +++ b/drivers/pps/Makefile
831 @@ -0,0 +1,11 @@
832 +#
833 +# Makefile for the PPS core.
834 +#
835 +
836 +pps_core-objs += pps.o kapi.o sysfs.o
837 +obj-$(CONFIG_PPS) += pps_core.o
838 +obj-y += clients/
839 +
840 +ifeq ($(CONFIG_PPS_DEBUG),y)
841 +EXTRA_CFLAGS += -DDEBUG
842 +endif
843 diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
844 new file mode 100644
845 index 0000000..09ba5c3
846 --- /dev/null
847 +++ b/drivers/pps/clients/Kconfig
848 @@ -0,0 +1,38 @@
849 +#
850 +# PPS clients configuration
851 +#
852 +
853 +if PPS
854 +
855 +comment "PPS clients support"
856 +
857 +config PPS_CLIENT_KTIMER
858 + tristate "Kernel timer client (Testing client, use for debug)"
859 + help
860 + If you say yes here you get support for a PPS debugging client
861 + which uses a kernel timer to generate the PPS signal.
862 +
863 + This driver can also be built as a module. If so, the module
864 + will be called ktimer.ko.
865 +
866 +comment "UART serial support (forced off)"
867 + depends on ! (SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y))
868 +
869 +config PPS_CLIENT_UART
870 + bool "UART serial support"
871 + depends on SERIAL_CORE != n && !(PPS = m && SERIAL_CORE = y)
872 + help
873 + If you say yes here you get support for a PPS source connected
874 + with the CD (Carrier Detect) pin of your serial port.
875 +
876 +comment "Parallel printer support (forced off)"
877 + depends on !( PRINTER != n && !(PPS = m && PRINTER = y))
878 +
879 +config PPS_CLIENT_LP
880 + bool "Parallel printer support"
881 + depends on PRINTER != n && !(PPS = m && PRINTER = y)
882 + help
883 + If you say yes here you get support for a PPS source connected
884 + with the interrupt pin of your parallel port.
885 +
886 +endif
887 diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
888 new file mode 100644
889 index 0000000..f3c1e39
890 --- /dev/null
891 +++ b/drivers/pps/clients/Makefile
892 @@ -0,0 +1,9 @@
893 +#
894 +# Makefile for PPS clients.
895 +#
896 +
897 +obj-$(CONFIG_PPS_CLIENT_KTIMER) += ktimer.o
898 +
899 +ifeq ($(CONFIG_PPS_DEBUG),y)
900 +EXTRA_CFLAGS += -DDEBUG
901 +endif
902 diff --git a/drivers/pps/clients/ktimer.c b/drivers/pps/clients/ktimer.c
903 new file mode 100644
904 index 0000000..4d613ab
905 --- /dev/null
906 +++ b/drivers/pps/clients/ktimer.c
907 @@ -0,0 +1,114 @@
908 +/*
909 + * ktimer.c -- kernel timer test client
910 + *
911 + *
912 + * Copyright (C) 2005-2006 Rodolfo Giometti <giometti@linux.it>
913 + *
914 + * This program is free software; you can redistribute it and/or modify
915 + * it under the terms of the GNU General Public License as published by
916 + * the Free Software Foundation; either version 2 of the License, or
917 + * (at your option) any later version.
918 + *
919 + * This program is distributed in the hope that it will be useful,
920 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
921 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
922 + * GNU General Public License for more details.
923 + *
924 + * You should have received a copy of the GNU General Public License
925 + * along with this program; if not, write to the Free Software
926 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
927 + */
928 +
929 +
930 +#include <linux/kernel.h>
931 +#include <linux/module.h>
932 +#include <linux/init.h>
933 +#include <linux/time.h>
934 +#include <linux/timer.h>
935 +
936 +#include <linux/pps.h>
937 +
938 +/*
939 + * Global variables
940 + */
941 +
942 +static int source;
943 +static struct timer_list ktimer;
944 +
945 +/*
946 + * The kernel timer
947 + */
948 +
949 +static void pps_ktimer_event(unsigned long ptr)
950 +{
951 + pr_info("PPS event at %lu\n", jiffies);
952 +
953 + pps_event(source, PPS_CAPTUREASSERT, NULL);
954 +
955 + mod_timer(&ktimer, jiffies + HZ);
956 +}
957 +
958 +/*
959 + * The echo function
960 + */
961 +
962 +static void pps_ktimer_echo(int source, int event, void *data)
963 +{
964 + pr_info("echo %s %s for source %d\n",
965 + event & PPS_CAPTUREASSERT ? "assert" : "",
966 + event & PPS_CAPTURECLEAR ? "clear" : "",
967 + source);
968 +}
969 +
970 +/*
971 + * The PPS info struct
972 + */
973 +
974 +static struct pps_source_info pps_ktimer_info = {
975 + name : "ktimer",
976 + path : "",
977 + mode : PPS_CAPTUREASSERT | PPS_OFFSETASSERT | \
978 + PPS_ECHOASSERT | \
979 + PPS_CANWAIT | PPS_TSFMT_TSPEC,
980 + echo : pps_ktimer_echo,
981 + owner : THIS_MODULE,
982 +};
983 +
984 +/*
985 + * Module staff
986 + */
987 +
988 +static void __exit pps_ktimer_exit(void)
989 +{
990 + del_timer_sync(&ktimer);
991 + pps_unregister_source(source);
992 +
993 + pr_info("ktimer PPS source unregistered\n");
994 +}
995 +
996 +static int __init pps_ktimer_init(void)
997 +{
998 + int ret;
999 +
1000 + ret = pps_register_source(&pps_ktimer_info,
1001 + PPS_CAPTUREASSERT | PPS_OFFSETASSERT);
1002 + if (ret < 0) {
1003 + printk(KERN_ERR "cannot register ktimer source\n");
1004 + return ret;
1005 + }
1006 + source = ret;
1007 +
1008 + setup_timer(&ktimer, pps_ktimer_event, 0);
1009 + mod_timer(&ktimer, jiffies + HZ);
1010 +
1011 + pr_info("ktimer PPS source registered at %d\n", source);
1012 +
1013 + return 0;
1014 +}
1015 +
1016 +module_init(pps_ktimer_init);
1017 +module_exit(pps_ktimer_exit);
1018 +
1019 +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
1020 +MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
1021 +MODULE_LICENSE("GPL");
1022 diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
1023 new file mode 100644
1024 index 0000000..67290d5
1025 --- /dev/null
1026 +++ b/drivers/pps/kapi.c
1027 @@ -0,0 +1,271 @@
1028 +/*
1029 + * kapi.c -- kernel API
1030 + *
1031 + *
1032 + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
1033 + *
1034 + * This program is free software; you can redistribute it and/or modify
1035 + * it under the terms of the GNU General Public License as published by
1036 + * the Free Software Foundation; either version 2 of the License, or
1037 + * (at your option) any later version.
1038 + *
1039 + * This program is distributed in the hope that it will be useful,
1040 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1041 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1042 + * GNU General Public License for more details.
1043 + *
1044 + * You should have received a copy of the GNU General Public License
1045 + * along with this program; if not, write to the Free Software
1046 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1047 + */
1048 +
1049 +
1050 +#include <linux/kernel.h>
1051 +#include <linux/module.h>
1052 +#include <linux/init.h>
1053 +#include <linux/sched.h>
1054 +#include <linux/time.h>
1055 +#include <linux/spinlock.h>
1056 +#include <linux/idr.h>
1057 +#include <linux/fs.h>
1058 +#include <linux/pps.h>
1059 +
1060 +/*
1061 + * Local variables
1062 + */
1063 +
1064 +static spinlock_t idr_lock = SPIN_LOCK_UNLOCKED;
1065 +static DEFINE_IDR(pps_idr);
1066 +
1067 +/*
1068 + * Local functions
1069 + */
1070 +
1071 +static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
1072 +{
1073 + ts->nsec += offset->nsec;
1074 + if (ts->nsec >= NSEC_PER_SEC) {
1075 + ts->nsec -= NSEC_PER_SEC;
1076 + ts->sec++;
1077 + } else if (ts->nsec < 0) {
1078 + ts->nsec += NSEC_PER_SEC;
1079 + ts->sec--;
1080 + }
1081 + ts->sec += offset->sec;
1082 +}
1083 +
1084 +/*
1085 + * Exported functions
1086 + */
1087 +
1088 +int pps_register_source(struct pps_source_info *info, int default_params)
1089 +{
1090 + struct pps_device *pps;
1091 + int id;
1092 + int err;
1093 +
1094 + /* Sanity checks */
1095 + if ((info->mode & default_params) != default_params) {
1096 + printk(KERN_ERR "pps: %s: unsupported default parameters\n",
1097 + info->name);
1098 + err = -EINVAL;
1099 + goto pps_register_source_exit;
1100 + }
1101 + if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
1102 + info->echo == NULL) {
1103 + printk(KERN_ERR "pps: %s: echo function is not defined\n",
1104 + info->name);
1105 + err = -EINVAL;
1106 + goto pps_register_source_exit;
1107 + }
1108 + if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
1109 + printk(KERN_ERR "pps: %s: unspecified time format\n",
1110 + info->name);
1111 + err = -EINVAL;
1112 + goto pps_register_source_exit;
1113 + }
1114 +
1115 + /* Allocate memory for the new PPS source struct */
1116 + pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL);
1117 + if (pps == NULL) {
1118 + err = -ENOMEM;
1119 + goto pps_register_source_exit;
1120 + }
1121 +
1122 + /* Get new ID for the new PPS source */
1123 + if (idr_pre_get(&pps_idr, GFP_KERNEL) == 0) {
1124 + err = -ENOMEM;
1125 + goto kfree_pps;
1126 + }
1127 +
1128 + spin_lock_irq(&idr_lock);
1129 + err = idr_get_new(&pps_idr, pps, &id);
1130 + spin_unlock_irq(&idr_lock);
1131 +
1132 + if (err < 0)
1133 + goto kfree_pps;
1134 +
1135 + id = id & MAX_ID_MASK;
1136 + if (id >= PPS_MAX_SOURCES) {
1137 + printk(KERN_ERR "pps: %s: too much PPS sources in the system\n",
1138 + info->name);
1139 + err = -EBUSY;
1140 + goto free_idr;
1141 + }
1142 +
1143 + pps->id = id;
1144 + pps->params.api_version = PPS_API_VERS;
1145 + pps->params.mode = default_params;
1146 + pps->info = *info;
1147 +
1148 + init_waitqueue_head(&pps->queue);
1149 + spin_lock_init(&pps->lock);
1150 + atomic_set(&pps->usage, 0);
1151 + init_waitqueue_head(&pps->usage_queue);
1152 +
1153 + /* Create the char device */
1154 + err = pps_register_cdev(pps);
1155 + if (err < 0) {
1156 + printk(KERN_ERR "pps: %s: unable to create char device\n",
1157 + info->name);
1158 + goto free_idr;
1159 + }
1160 +
1161 + /* Create the sysfs entry */
1162 + err = pps_sysfs_create_source_entry(pps);
1163 + if (err < 0) {
1164 + printk(KERN_ERR "pps: %s: unable to create sysfs entries\n",
1165 + info->name);
1166 + goto unregister_cdev;
1167 + }
1168 +
1169 + pr_info("new PPS source %s at ID %d\n", info->name, id);
1170 +
1171 + return id;
1172 +
1173 +unregister_cdev:
1174 + pps_unregister_cdev(pps);
1175 +
1176 +free_idr:
1177 + spin_lock_irq(&idr_lock);
1178 + idr_remove(&pps_idr, id);
1179 + spin_unlock_irq(&idr_lock);
1180 +
1181 +kfree_pps:
1182 + kfree(pps);
1183 +
1184 +pps_register_source_exit:
1185 + printk(KERN_ERR "pps: %s: unable to register source\n", info->name);
1186 +
1187 + return err;
1188 +}
1189 +EXPORT_SYMBOL(pps_register_source);
1190 +
1191 +void pps_unregister_source(int source)
1192 +{
1193 + struct pps_device *pps;
1194 +
1195 + spin_lock_irq(&idr_lock);
1196 + pps = idr_find(&pps_idr, source);
1197 +
1198 + if (!pps) {
1199 + spin_unlock_irq(&idr_lock);
1200 + return;
1201 + }
1202 +
1203 + /* This should be done first in order to deny IRQ handlers
1204 + * to access PPS structs
1205 + */
1206 +
1207 + idr_remove(&pps_idr, pps->id);
1208 + spin_unlock_irq(&idr_lock);
1209 +
1210 + wait_event(pps->usage_queue, atomic_read(&pps->usage) == 0);
1211 +
1212 + pps_sysfs_remove_source_entry(pps);
1213 + pps_unregister_cdev(pps);
1214 + kfree(pps);
1215 +}
1216 +EXPORT_SYMBOL(pps_unregister_source);
1217 +
1218 +void pps_event(int source, int event, void *data)
1219 +{
1220 + struct pps_device *pps;
1221 + struct timespec __ts;
1222 + struct pps_ktime ts;
1223 + unsigned long flags;
1224 +
1225 + /* First of all we get the time stamp... */
1226 + getnstimeofday(&__ts);
1227 +
1228 + /* ... and translate it to PPS time data struct */
1229 + ts.sec = __ts.tv_sec;
1230 + ts.nsec = __ts.tv_nsec;
1231 +
1232 + if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0 ) {
1233 + printk(KERN_ERR "pps: unknown event (%x) for source %d\n",
1234 + event, source);
1235 + return;
1236 + }
1237 +
1238 + spin_lock_irqsave(&idr_lock, flags);
1239 + pps = idr_find(&pps_idr, source);
1240 +
1241 + /* If we find a valid PPS source we lock it before leaving
1242 + * the lock!
1243 + */
1244 + if (pps)
1245 + atomic_inc(&pps->usage);
1246 + spin_unlock_irqrestore(&idr_lock, flags);
1247 +
1248 + if (!pps)
1249 + return;
1250 +
1251 + pr_debug("PPS event on source %d at at %llu.%06u\n",
1252 + pps->id, ts.sec, ts.nsec);
1253 +
1254 + spin_lock_irqsave(&pps->lock, flags);
1255 +
1256 + /* Must call the echo function? */
1257 + if ((pps->params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
1258 + pps->info.echo(source, event, data);
1259 +
1260 + /* Check the event */
1261 + pps->current_mode = pps->params.mode;
1262 + if (event & PPS_CAPTUREASSERT) {
1263 + /* We have to add an offset? */
1264 + if (pps->params.mode & PPS_OFFSETASSERT)
1265 + pps_add_offset(&ts, &pps->params.assert_off_tu);
1266 +
1267 + /* Save the time stamp */
1268 + pps->assert_tu = ts;
1269 + pps->assert_sequence++;
1270 + pr_debug("capture assert seq #%u for source %d\n",
1271 + pps->assert_sequence, source);
1272 + }
1273 + if (event & PPS_CAPTURECLEAR) {
1274 + /* We have to add an offset? */
1275 + if (pps->params.mode & PPS_OFFSETCLEAR)
1276 + pps_add_offset(&ts, &pps->params.clear_off_tu);
1277 +
1278 + /* Save the time stamp */
1279 + pps->clear_tu = ts;
1280 + pps->clear_sequence++;
1281 + pr_debug("capture clear seq #%u for source %d\n",
1282 + pps->clear_sequence, source);
1283 + }
1284 +
1285 + pps->go = ~0;
1286 + wake_up_interruptible(&pps->queue);
1287 +
1288 + kill_fasync(&pps->async_queue, SIGIO, POLL_IN);
1289 +
1290 + spin_unlock_irqrestore(&pps->lock, flags);
1291 +
1292 + /* Now we can release the PPS source for (possible) deregistration */
1293 + spin_lock_irqsave(&idr_lock, flags);
1294 + atomic_dec(&pps->usage);
1295 + wake_up_all(&pps->usage_queue);
1296 + spin_unlock_irqrestore(&idr_lock, flags);
1297 +}
1298 +EXPORT_SYMBOL(pps_event);
1299 diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
1300 new file mode 100644
1301 index 0000000..52de2f1
1302 --- /dev/null
1303 +++ b/drivers/pps/pps.c
1304 @@ -0,0 +1,332 @@
1305 +/*
1306 + * pps.c -- Main PPS support file
1307 + *
1308 + *
1309 + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
1310 + *
1311 + * This program is free software; you can redistribute it and/or modify
1312 + * it under the terms of the GNU General Public License as published by
1313 + * the Free Software Foundation; either version 2 of the License, or
1314 + * (at your option) any later version.
1315 + *
1316 + * This program is distributed in the hope that it will be useful,
1317 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1318 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1319 + * GNU General Public License for more details.
1320 + *
1321 + * You should have received a copy of the GNU General Public License
1322 + * along with this program; if not, write to the Free Software
1323 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1324 + */
1325 +
1326 +
1327 +#include <linux/kernel.h>
1328 +#include <linux/version.h>
1329 +#include <linux/module.h>
1330 +#include <linux/init.h>
1331 +#include <linux/sched.h>
1332 +#include <linux/uaccess.h>
1333 +#include <linux/cdev.h>
1334 +#include <linux/poll.h>
1335 +#include <linux/pps.h>
1336 +
1337 +/*
1338 + * Local variables
1339 + */
1340 +
1341 +static dev_t pps_devt;
1342 +static struct class *pps_class;
1343 +
1344 +/*
1345 + * Char device methods
1346 + */
1347 +
1348 +static unsigned int pps_cdev_poll(struct file *file, poll_table *wait)
1349 +{
1350 + struct pps_device *pps = file->private_data;
1351 +
1352 + poll_wait(file, &pps->queue, wait);
1353 +
1354 + return POLLIN | POLLRDNORM;
1355 +}
1356 +
1357 +static int pps_cdev_fasync(int fd, struct file *file, int on)
1358 +{
1359 + struct pps_device *pps = file->private_data;
1360 + return fasync_helper(fd, file, on, &pps->async_queue);
1361 +}
1362 +
1363 +static int pps_cdev_ioctl(struct inode *inode, struct file *file,
1364 + unsigned int cmd, unsigned long arg)
1365 +{
1366 + struct pps_device *pps = file->private_data;
1367 + struct pps_kparams params;
1368 + struct pps_fdata fdata;
1369 + unsigned long ticks;
1370 + void __user *uarg = (void __user *) arg;
1371 + int __user *iuarg = (int __user *) arg;
1372 + int err;
1373 +
1374 + switch (cmd) {
1375 + case PPS_CHECK:
1376 +
1377 + /* This does nothing but signal we are a PPS source... */
1378 +
1379 + return 0;
1380 +
1381 + case PPS_GETPARAMS:
1382 + pr_debug("PPS_GETPARAMS: source %d\n", pps->id);
1383 +
1384 + /* Sanity checks */
1385 + if (!uarg)
1386 + return -EINVAL;
1387 +
1388 + /* Return current parameters */
1389 + err = copy_to_user(uarg, &pps->params,
1390 + sizeof(struct pps_kparams));
1391 + if (err)
1392 + return -EFAULT;
1393 +
1394 + break;
1395 +
1396 + case PPS_SETPARAMS:
1397 + pr_debug("PPS_SETPARAMS: source %d\n", pps->id);
1398 +
1399 + /* Check the capabilities */
1400 + if (!capable(CAP_SYS_TIME))
1401 + return -EPERM;
1402 +
1403 + /* Sanity checks */
1404 + if (!uarg)
1405 + return -EINVAL;
1406 + err = copy_from_user(&params, uarg, sizeof(struct pps_kparams));
1407 + if (err)
1408 + return -EFAULT;
1409 + if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
1410 + pr_debug("capture mode unspecified (%x)\n",
1411 + params.mode);
1412 + return -EINVAL;
1413 + }
1414 +
1415 + /* Check for supported capabilities */
1416 + if ((params.mode & ~pps->info.mode) != 0) {
1417 + pr_debug("unsupported capabilities (%x)\n",
1418 + params.mode);
1419 + return -EINVAL;
1420 + }
1421 +
1422 + spin_lock_irq(&pps->lock);
1423 +
1424 + /* Save the new parameters */
1425 + pps->params = params;
1426 +
1427 + /* Restore the read only parameters */
1428 + if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
1429 + /* section 3.3 of RFC 2783 interpreted */
1430 + pr_debug("time format unspecified (%x)\n",
1431 + params.mode);
1432 + pps->params.mode |= PPS_TSFMT_TSPEC;
1433 + }
1434 + if (pps->info.mode & PPS_CANWAIT)
1435 + pps->params.mode |= PPS_CANWAIT;
1436 + pps->params.api_version = PPS_API_VERS;
1437 +
1438 + spin_unlock_irq(&pps->lock);
1439 +
1440 + break;
1441 +
1442 + case PPS_GETCAP:
1443 + pr_debug("PPS_GETCAP: source %d\n", pps->id);
1444 +
1445 + /* Sanity checks */
1446 + if (!uarg)
1447 + return -EINVAL;
1448 +
1449 + err = put_user(pps->info.mode, iuarg);
1450 + if (err)
1451 + return -EFAULT;
1452 +
1453 + break;
1454 +
1455 + case PPS_FETCH:
1456 + pr_debug("PPS_FETCH: source %d\n", pps->id);
1457 +
1458 + if (!uarg)
1459 + return -EINVAL;
1460 + err = copy_from_user(&fdata, uarg, sizeof(struct pps_fdata));
1461 + if (err)
1462 + return -EFAULT;
1463 +
1464 + pps->go = 0;
1465 +
1466 + /* Manage the timeout */
1467 + if (fdata.timeout.flags & PPS_TIME_INVALID)
1468 + err = wait_event_interruptible(pps->queue, pps->go);
1469 + else {
1470 + pr_debug("timeout %lld.%09d\n",
1471 + fdata.timeout.sec, fdata.timeout.nsec);
1472 + ticks = fdata.timeout.sec * HZ;
1473 + ticks += fdata.timeout.nsec / (NSEC_PER_SEC / HZ);
1474 +
1475 + if (ticks != 0) {
1476 + err = wait_event_interruptible_timeout(
1477 + pps->queue, pps->go, ticks);
1478 + if (err == 0)
1479 + return -ETIMEDOUT;
1480 + }
1481 + }
1482 +
1483 + /* Check for pending signals */
1484 + if (err == -ERESTARTSYS) {
1485 + pr_debug("pending signal caught\n");
1486 + return -EINTR;
1487 + }
1488 +
1489 + /* Return the fetched timestamp */
1490 + spin_lock_irq(&pps->lock);
1491 +
1492 + fdata.info.assert_sequence = pps->assert_sequence;
1493 + fdata.info.clear_sequence = pps->clear_sequence;
1494 + fdata.info.assert_tu = pps->assert_tu;
1495 + fdata.info.clear_tu = pps->clear_tu;
1496 + fdata.info.current_mode = pps->current_mode;
1497 +
1498 + spin_unlock_irq(&pps->lock);
1499 +
1500 + err = copy_to_user(uarg, &fdata, sizeof(struct pps_fdata));
1501 + if (err)
1502 + return -EFAULT;
1503 +
1504 + break;
1505 +
1506 + default:
1507 + return -ENOTTY;
1508 + break;
1509 + }
1510 +
1511 + return 0;
1512 +}
1513 +
1514 +static int pps_cdev_open(struct inode *inode, struct file *file)
1515 +{
1516 + struct pps_device *pps = container_of(inode->i_cdev,
1517 + struct pps_device, cdev);
1518 +
1519 + /* Lock the PPS source against (possible) deregistration */
1520 + atomic_inc(&pps->usage);
1521 +
1522 + file->private_data = pps;
1523 +
1524 + return 0;
1525 +}
1526 +
1527 +static int pps_cdev_release(struct inode *inode, struct file *file)
1528 +{
1529 + struct pps_device *pps = file->private_data;
1530 +
1531 + /* Free the PPS source and wake up (possible) deregistration */
1532 + atomic_dec(&pps->usage);
1533 + wake_up_all(&pps->usage_queue);
1534 +
1535 + return 0;
1536 +}
1537 +
1538 +/*
1539 + * Char device stuff
1540 + */
1541 +
1542 +static const struct file_operations pps_cdev_fops = {
1543 + .owner = THIS_MODULE,
1544 + .llseek = no_llseek,
1545 + .poll = pps_cdev_poll,
1546 + .fasync = pps_cdev_fasync,
1547 + .ioctl = pps_cdev_ioctl,
1548 + .open = pps_cdev_open,
1549 + .release = pps_cdev_release,
1550 +};
1551 +
1552 +int pps_register_cdev(struct pps_device *pps)
1553 +{
1554 + int err;
1555 +
1556 + pps->devno = MKDEV(MAJOR(pps_devt), pps->id);
1557 + cdev_init(&pps->cdev, &pps_cdev_fops);
1558 + pps->cdev.owner = pps->info.owner;
1559 +
1560 + err = cdev_add(&pps->cdev, pps->devno, 1);
1561 + if (err) {
1562 + printk(KERN_ERR "pps: %s: failed to add char device %d:%d\n",
1563 + pps->info.name, MAJOR(pps_devt), pps->id);
1564 + return err;
1565 + }
1566 + pps->dev = device_create(pps_class, pps->info.dev, pps->devno,
1567 + "pps%d", pps->id);
1568 + if (err)
1569 + goto del_cdev;
1570 + dev_set_drvdata(pps->dev, pps);
1571 +
1572 + pr_debug("source %s got cdev (%d:%d)\n", pps->info.name,
1573 + MAJOR(pps_devt), pps->id);
1574 +
1575 + return 0;
1576 +
1577 +del_cdev:
1578 + cdev_del(&pps->cdev);
1579 +
1580 + return err;
1581 +}
1582 +
1583 +void pps_unregister_cdev(struct pps_device *pps)
1584 +{
1585 + device_destroy(pps_class, pps->devno);
1586 + cdev_del(&pps->cdev);
1587 +}
1588 +
1589 +/*
1590 + * Module staff
1591 + */
1592 +
1593 +static void __exit pps_exit(void)
1594 +{
1595 + class_destroy(pps_class);
1596 +
1597 + if (pps_devt)
1598 + unregister_chrdev_region(pps_devt, PPS_MAX_SOURCES);
1599 +
1600 + pr_info("LinuxPPS API ver. %d removed\n", PPS_API_VERS);
1601 +}
1602 +
1603 +static int __init pps_init(void)
1604 +{
1605 + int err;
1606 +
1607 + pps_class = class_create(THIS_MODULE, "pps");
1608 + if (!pps_class) {
1609 + printk(KERN_ERR "pps: ailed to allocate class\n");
1610 + return -ENOMEM;
1611 + }
1612 +
1613 + err = alloc_chrdev_region(&pps_devt, 0, PPS_MAX_SOURCES, "pps");
1614 + if (err < 0) {
1615 + printk(KERN_ERR "pps: failed to allocate char device region\n");
1616 + goto remove_class;
1617 + }
1618 +
1619 + pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS);
1620 + pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
1621 + "<giometti@linux.it>\n", PPS_VERSION);
1622 +
1623 + return 0;
1624 +
1625 +remove_class:
1626 + class_destroy(pps_class);
1627 +
1628 + return err;
1629 +}
1630 +
1631 +subsys_initcall(pps_init);
1632 +module_exit(pps_exit);
1633 +
1634 +MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
1635 +MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
1636 +MODULE_LICENSE("GPL");
1637 diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
1638 new file mode 100644
1639 index 0000000..8541be7
1640 --- /dev/null
1641 +++ b/drivers/pps/sysfs.c
1642 @@ -0,0 +1,124 @@
1643 +/*
1644 + * sysfs.c -- sysfs support
1645 + *
1646 + *
1647 + * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
1648 + *
1649 + * This program is free software; you can redistribute it and/or modify
1650 + * it under the terms of the GNU General Public License as published by
1651 + * the Free Software Foundation; either version 2 of the License, or
1652 + * (at your option) any later version.
1653 + *
1654 + * This program is distributed in the hope that it will be useful,
1655 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1656 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1657 + * GNU General Public License for more details.
1658 + *
1659 + * You should have received a copy of the GNU General Public License
1660 + * along with this program; if not, write to the Free Software
1661 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1662 + */
1663 +
1664 +
1665 +#include <linux/device.h>
1666 +#include <linux/module.h>
1667 +#include <linux/string.h>
1668 +#include <linux/pps.h>
1669 +
1670 +/*
1671 + * Attribute functions
1672 + */
1673 +
1674 +static ssize_t pps_show_assert(struct device *dev,
1675 + struct device_attribute *attr, char *buf)
1676 +{
1677 + struct pps_device *pps = dev_get_drvdata(dev);
1678 +
1679 + return sprintf(buf, "%lld.%09d#%d\n",
1680 + pps->assert_tu.sec, pps->assert_tu.nsec,
1681 + pps->assert_sequence);
1682 +}
1683 +DEVICE_ATTR(assert, S_IRUGO, pps_show_assert, NULL);
1684 +
1685 +static ssize_t pps_show_clear(struct device *dev,
1686 + struct device_attribute *attr, char *buf)
1687 +{
1688 + struct pps_device *pps = dev_get_drvdata(dev);
1689 +
1690 + return sprintf(buf, "%lld.%09d#%d\n",
1691 + pps->clear_tu.sec, pps->clear_tu.nsec,
1692 + pps->clear_sequence);
1693 +}
1694 +DEVICE_ATTR(clear, S_IRUGO, pps_show_clear, NULL);
1695 +
1696 +static ssize_t pps_show_mode(struct device *dev,
1697 + struct device_attribute *attr, char *buf)
1698 +{
1699 + struct pps_device *pps = dev_get_drvdata(dev);
1700 +
1701 + return sprintf(buf, "%4x\n", pps->info.mode);
1702 +}
1703 +DEVICE_ATTR(mode, S_IRUGO, pps_show_mode, NULL);
1704 +
1705 +static ssize_t pps_show_echo(struct device *dev,
1706 + struct device_attribute *attr, char *buf)
1707 +{
1708 + struct pps_device *pps = dev_get_drvdata(dev);
1709 +
1710 + return sprintf(buf, "%d\n", !!pps->info.echo);
1711 +}
1712 +DEVICE_ATTR(echo, S_IRUGO, pps_show_echo, NULL);
1713 +
1714 +static ssize_t pps_show_name(struct device *dev,
1715 + struct device_attribute *attr, char *buf)
1716 +{
1717 + struct pps_device *pps = dev_get_drvdata(dev);
1718 +
1719 + return sprintf(buf, "%s\n", pps->info.name);
1720 +}
1721 +DEVICE_ATTR(name, S_IRUGO, pps_show_name, NULL);
1722 +
1723 +static ssize_t pps_show_path(struct device *dev,
1724 + struct device_attribute *attr, char *buf)
1725 +{
1726 + struct pps_device *pps = dev_get_drvdata(dev);
1727 +
1728 + return sprintf(buf, "%s\n", pps->info.path);
1729 +}
1730 +DEVICE_ATTR(path, S_IRUGO, pps_show_path, NULL);
1731 +
1732 +/*
1733 + * Public functions
1734 + */
1735 +
1736 +void pps_sysfs_remove_source_entry(struct pps_device *pps)
1737 +{
1738 + /* Delete info files */
1739 + if (pps->info.mode & PPS_CAPTUREASSERT)
1740 + device_remove_file(pps->dev, &dev_attr_assert);
1741 +
1742 + if (pps->info.mode & PPS_CAPTURECLEAR)
1743 + device_remove_file(pps->dev, &dev_attr_clear);
1744 +
1745 + device_remove_file(pps->dev, &dev_attr_mode);
1746 + device_remove_file(pps->dev, &dev_attr_echo);
1747 + device_remove_file(pps->dev, &dev_attr_name);
1748 + device_remove_file(pps->dev, &dev_attr_path);
1749 +}
1750 +
1751 +int pps_sysfs_create_source_entry(struct pps_device *pps)
1752 +{
1753 + /* Create file "assert" and "clear" according to source capability */
1754 + if (pps->info.mode & PPS_CAPTUREASSERT)
1755 + device_create_file(pps->dev, &dev_attr_assert);
1756 +
1757 + if (pps->info.mode & PPS_CAPTURECLEAR)
1758 + device_create_file(pps->dev, &dev_attr_clear);
1759 +
1760 + device_create_file(pps->dev, &dev_attr_mode);
1761 + device_create_file(pps->dev, &dev_attr_echo);
1762 + device_create_file(pps->dev, &dev_attr_name);
1763 + device_create_file(pps->dev, &dev_attr_path);
1764 +
1765 + return 0;
1766 +}
1767 diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
1768 index f94109c..a5e83f8 100644
1769 --- a/drivers/serial/8250.c
1770 +++ b/drivers/serial/8250.c
1771 @@ -2118,6 +2118,8 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
1772 up->ier |= UART_IER_MSI;
1773 if (up->capabilities & UART_CAP_UUE)
1774 up->ier |= UART_IER_UUE | UART_IER_RTOIE;
1775 + if (up->port.flags & UPF_HARDPPS_CD)
1776 + up->ier |= UART_IER_MSI; /* enable interrupts */
1777
1778 serial_out(up, UART_IER, up->ier);
1779
1780 diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
1781 index a055f58..a40b87c 100644
1782 --- a/drivers/serial/serial_core.c
1783 +++ b/drivers/serial/serial_core.c
1784 @@ -33,6 +33,7 @@
1785 #include <linux/serial.h> /* for serial_state and serial_icounter_struct */
1786 #include <linux/delay.h>
1787 #include <linux/mutex.h>
1788 +#include <linux/pps.h>
1789
1790 #include <asm/irq.h>
1791 #include <asm/uaccess.h>
1792 @@ -633,6 +634,54 @@ static int uart_get_info(struct uart_state *state,
1793 return 0;
1794 }
1795
1796 +#ifdef CONFIG_PPS_CLIENT_UART
1797 +
1798 +static int
1799 +uart_register_pps_port(struct uart_state *state, struct uart_port *port)
1800 +{
1801 + struct tty_driver *drv = port->info->tty->driver;
1802 + int ret;
1803 +
1804 + state->pps_info.owner = THIS_MODULE;
1805 + state->pps_info.dev = port->dev;
1806 + snprintf(state->pps_info.name, PPS_MAX_NAME_LEN, "%s%d",
1807 + drv->driver_name, port->line);
1808 + snprintf(state->pps_info.path, PPS_MAX_NAME_LEN, "/dev/%s%d",
1809 + drv->name, port->line);
1810 +
1811 + state->pps_info.mode = PPS_CAPTUREBOTH | \
1812 + PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
1813 + PPS_CANWAIT | PPS_TSFMT_TSPEC;
1814 +
1815 + ret = pps_register_source(&state->pps_info, PPS_CAPTUREBOTH | \
1816 + PPS_OFFSETASSERT | PPS_OFFSETCLEAR);
1817 + if (ret < 0) {
1818 + dev_err(port->dev, "cannot register PPS source \"%s\"\n",
1819 + state->pps_info.path);
1820 + return ret;
1821 + }
1822 + port->pps_source = ret;
1823 + dev_dbg(port->dev, "PPS source #%d \"%s\" added\n",
1824 + port->pps_source, state->pps_info.path);
1825 +
1826 + return 0;
1827 +}
1828 +
1829 +static void
1830 +uart_unregister_pps_port(struct uart_state *state, struct uart_port *port)
1831 +{
1832 + pps_unregister_source(port->pps_source);
1833 + dev_dbg(port->dev, "PPS source #%d \"%s\" removed\n",
1834 + port->pps_source, state->pps_info.path);
1835 +}
1836 +
1837 +#else
1838 +
1839 +#define uart_register_pps_port(state, port) do { } while (0)
1840 +#define uart_unregister_pps_port(state, port) do { } while (0)
1841 +
1842 +#endif /* CONFIG_PPS_CLIENT_UART */
1843 +
1844 static int uart_set_info(struct uart_state *state,
1845 struct serial_struct __user *newinfo)
1846 {
1847 @@ -807,11 +856,19 @@ static int uart_set_info(struct uart_state *state,
1848 (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1849
1850 check_and_exit:
1851 + /* PPS support enabled/disabled? */
1852 + if ((old_flags & UPF_HARDPPS_CD) != (new_flags & UPF_HARDPPS_CD)) {
1853 + if (new_flags & UPF_HARDPPS_CD)
1854 + uart_register_pps_port(state, port);
1855 + else
1856 + uart_unregister_pps_port(state, port);
1857 + }
1858 +
1859 retval = 0;
1860 if (port->type == PORT_UNKNOWN)
1861 goto exit;
1862 if (state->info->flags & UIF_INITIALIZED) {
1863 - if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
1864 + if (((old_flags ^ port->flags) & (UPF_SPD_MASK|UPF_HARDPPS_CD)) ||
1865 old_custom_divisor != port->custom_divisor) {
1866 /*
1867 * If they're setting up a custom divisor or speed,
1868 @@ -2110,6 +2167,12 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
1869 port->ops->config_port(port, flags);
1870 }
1871
1872 + /*
1873 + * Add the PPS support for the current port.
1874 + */
1875 + if (port->flags & UPF_HARDPPS_CD)
1876 + uart_register_pps_port(state, port);
1877 +
1878 if (port->type != PORT_UNKNOWN) {
1879 unsigned long flags;
1880
1881 @@ -2359,6 +2422,12 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
1882 mutex_unlock(&state->mutex);
1883
1884 /*
1885 + * Remove PPS support from the current port.
1886 + */
1887 + if (port->flags & UPF_HARDPPS_CD)
1888 + uart_unregister_pps_port(state, port);
1889 +
1890 + /*
1891 * Remove the devices from the tty layer
1892 */
1893 tty_unregister_device(drv->tty_driver, port->line);
1894 diff --git a/include/linux/Kbuild b/include/linux/Kbuild
1895 index 818cc3a..0a9394f 100644
1896 --- a/include/linux/Kbuild
1897 +++ b/include/linux/Kbuild
1898 @@ -295,6 +295,7 @@ unifdef-y += pmu.h
1899 unifdef-y += poll.h
1900 unifdef-y += ppp_defs.h
1901 unifdef-y += ppp-comp.h
1902 +unifdef-y += pps.h
1903 unifdef-y += ptrace.h
1904 unifdef-y += qnx4_fs.h
1905 unifdef-y += quota.h
1906 diff --git a/include/linux/parport.h b/include/linux/parport.h
1907 index 9cdd694..549de6e 100644
1908 --- a/include/linux/parport.h
1909 +++ b/include/linux/parport.h
1910 @@ -100,6 +100,7 @@ typedef enum {
1911 #include <linux/proc_fs.h>
1912 #include <linux/spinlock.h>
1913 #include <linux/wait.h>
1914 +#include <linux/pps.h>
1915 #include <asm/system.h>
1916 #include <asm/ptrace.h>
1917 #include <asm/semaphore.h>
1918 @@ -327,6 +328,11 @@ struct parport {
1919
1920 struct list_head full_list;
1921 struct parport *slaves[3];
1922 +
1923 +#ifdef CONFIG_PPS_CLIENT_LP
1924 + struct pps_source_info pps_info;
1925 + int pps_source; /* PPS source ID */
1926 +#endif
1927 };
1928
1929 #define DEFAULT_SPIN_TIME 500 /* us */
1930 @@ -517,6 +523,12 @@ extern int parport_daisy_select (struct parport *port, int daisy, int mode);
1931 /* Lowlevel drivers _can_ call this support function to handle irqs. */
1932 static __inline__ void parport_generic_irq(int irq, struct parport *port)
1933 {
1934 +#ifdef CONFIG_PPS_CLIENT_LP
1935 + pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
1936 + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n",
1937 + jiffies, port->pps_source);
1938 +#endif
1939 +
1940 parport_ieee1284_interrupt (irq, port);
1941 read_lock(&port->cad_lock);
1942 if (port->cad && port->cad->irq_func)
1943 diff --git a/include/linux/pps.h b/include/linux/pps.h
1944 new file mode 100644
1945 index 0000000..5bdb593
1946 --- /dev/null
1947 +++ b/include/linux/pps.h
1948 @@ -0,0 +1,196 @@
1949 +/*
1950 + * pps.h -- PPS API kernel header.
1951 + *
1952 + *
1953 + * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>
1954 + *
1955 + * This program is free software; you can redistribute it and/or modify
1956 + * it under the terms of the GNU General Public License as published by
1957 + * the Free Software Foundation; either version 2 of the License, or
1958 + * (at your option) any later version.
1959 + *
1960 + * This program is distributed in the hope that it will be useful,
1961 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1962 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1963 + * GNU General Public License for more details.
1964 + *
1965 + * You should have received a copy of the GNU General Public License
1966 + * along with this program; if not, write to the Free Software
1967 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1968 + */
1969 +
1970 +
1971 +#ifndef _PPS_H_
1972 +#define _PPS_H_
1973 +
1974 +/* Implementation note: the logical states ``assert'' and ``clear''
1975 + * are implemented in terms of the chip register, i.e. ``assert''
1976 + * means the bit is set. */
1977 +
1978 +/*
1979 + * 3.2 New data structures
1980 + */
1981 +
1982 +#ifndef __KERNEL__
1983 +#include <linux/types.h>
1984 +#include <sys/time.h>
1985 +#include <sys/ioctl.h>
1986 +#else
1987 +#include <linux/time.h>
1988 +#endif
1989 +
1990 +#define PPS_API_VERS 1
1991 +#define PPS_MAX_NAME_LEN 32
1992 +
1993 +/* 32-bit vs. 64-bit compatibility.
1994 + *
1995 + * 0n i386, the alignment of a uint64_t is only 4 bytes, while on most other
1996 + * architectures it's 8 bytes. On i386, there will be no padding between the
1997 + * two consecutive 'struct pps_ktime' members of struct pps_kinfo and struct
1998 + * pps_kparams. But on most platforms there will be padding to ensure correct
1999 + * alignment.
2000 + *
2001 + * The simple fix is probably to add an explicit padding.
2002 + * [David Woodhouse]
2003 + */
2004 +struct pps_ktime {
2005 + __u64 sec;
2006 + __u32 nsec;
2007 + __u32 flags;
2008 +};
2009 +#define PPS_TIME_INVALID (1<<0) /* used to specify timeout==NULL */
2010 +
2011 +struct pps_kinfo {
2012 + __u32 assert_sequence; /* seq. num. of assert event */
2013 + __u32 clear_sequence; /* seq. num. of clear event */
2014 + struct pps_ktime assert_tu; /* time of assert event */
2015 + struct pps_ktime clear_tu; /* time of clear event */
2016 + int current_mode; /* current mode bits */
2017 +};
2018 +
2019 +struct pps_kparams {
2020 + int api_version; /* API version # */
2021 + int mode; /* mode bits */
2022 + struct pps_ktime assert_off_tu; /* offset compensation for assert */
2023 + struct pps_ktime clear_off_tu; /* offset compensation for clear */
2024 +};
2025 +
2026 +/*
2027 + * 3.3 Mode bit definitions
2028 + */
2029 +
2030 +/* Device/implementation parameters */
2031 +#define PPS_CAPTUREASSERT 0x01 /* capture assert events */
2032 +#define PPS_CAPTURECLEAR 0x02 /* capture clear events */
2033 +#define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
2034 +
2035 +#define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
2036 +#define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
2037 +
2038 +#define PPS_CANWAIT 0x100 /* can we wait for an event? */
2039 +#define PPS_CANPOLL 0x200 /* bit reserved for future use */
2040 +
2041 +/* Kernel actions */
2042 +#define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
2043 +#define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
2044 +
2045 +/* Timestamp formats */
2046 +#define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
2047 +#define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
2048 +
2049 +/*
2050 + * 3.4.4 New functions: disciplining the kernel timebase
2051 + */
2052 +
2053 +/* Kernel consumers */
2054 +#define PPS_KC_HARDPPS 0 /* hardpps() (or equivalent) */
2055 +#define PPS_KC_HARDPPS_PLL 1 /* hardpps() constrained to
2056 + use a phase-locked loop */
2057 +#define PPS_KC_HARDPPS_FLL 2 /* hardpps() constrained to
2058 + use a frequency-locked loop */
2059 +/*
2060 + * Here begins the implementation-specific part!
2061 + */
2062 +
2063 +struct pps_fdata {
2064 + struct pps_kinfo info;
2065 + struct pps_ktime timeout;
2066 +};
2067 +
2068 +#include <linux/ioctl.h>
2069 +
2070 +#define PPS_CHECK _IO('P', 0)
2071 +#define PPS_GETPARAMS _IOR('P', 1, struct pps_kparams *)
2072 +#define PPS_SETPARAMS _IOW('P', 2, struct pps_kparams *)
2073 +#define PPS_GETCAP _IOR('P', 3, int *)
2074 +#define PPS_FETCH _IOWR('P', 4, struct pps_fdata *)
2075 +
2076 +#ifdef __KERNEL__
2077 +
2078 +#include <linux/cdev.h>
2079 +#include <linux/device.h>
2080 +
2081 +#define PPS_VERSION "5.0.0-rc2"
2082 +#define PPS_MAX_SOURCES 16 /* should be enought... */
2083 +
2084 +/*
2085 + * Global defines
2086 + */
2087 +
2088 +/* The specific PPS source info */
2089 +struct pps_source_info {
2090 + char name[PPS_MAX_NAME_LEN]; /* simbolic name */
2091 + char path[PPS_MAX_NAME_LEN]; /* path of connected device */
2092 + int mode; /* PPS's allowed mode */
2093 +
2094 + void (*echo)(int source, int event, void *data); /* PPS echo function */
2095 +
2096 + struct module *owner;
2097 + struct device *dev;
2098 +};
2099 +
2100 +/* The main struct */
2101 +struct pps_device {
2102 + struct pps_source_info info; /* PSS source info */
2103 +
2104 + struct pps_kparams params; /* PPS's current params */
2105 +
2106 + __u32 assert_sequence; /* PPS' assert event seq # */
2107 + __u32 clear_sequence; /* PPS' clear event seq # */
2108 + struct pps_ktime assert_tu;
2109 + struct pps_ktime clear_tu;
2110 + int current_mode; /* PPS mode at event time */
2111 +
2112 + int go; /* PPS event is arrived? */
2113 + wait_queue_head_t queue; /* PPS event queue */
2114 +
2115 + unsigned int id; /* PPS source unique ID */
2116 + struct cdev cdev;
2117 + struct device *dev;
2118 + int devno;
2119 + struct fasync_struct *async_queue; /* fasync method */
2120 + spinlock_t lock;
2121 +
2122 + atomic_t usage; /* usage count */
2123 + wait_queue_head_t usage_queue;
2124 +
2125 + struct class_device class_dev;
2126 +};
2127 +
2128 +/*
2129 + * Exported functions
2130 + */
2131 +
2132 +extern int pps_register_source(struct pps_source_info *info,
2133 + int default_params);
2134 +extern void pps_unregister_source(int source);
2135 +extern int pps_register_cdev(struct pps_device *pps);
2136 +extern void pps_unregister_cdev(struct pps_device *pps);
2137 +extern void pps_event(int source, int event, void *data);
2138 +
2139 +extern int pps_sysfs_create_source_entry(struct pps_device *pps);
2140 +extern void pps_sysfs_remove_source_entry(struct pps_device *pps);
2141 +
2142 +#endif /* __KERNEL__ */
2143 +
2144 +#endif /* _PPS_H_ */
2145 diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
2146 index 09d17b0..f9aefad 100644
2147 --- a/include/linux/serial_core.h
2148 +++ b/include/linux/serial_core.h
2149 @@ -157,6 +157,7 @@
2150 #include <linux/tty.h>
2151 #include <linux/mutex.h>
2152 #include <linux/sysrq.h>
2153 +#include <linux/pps.h>
2154
2155 struct uart_port;
2156 struct uart_info;
2157 @@ -236,6 +237,9 @@ struct uart_port {
2158 unsigned char regshift; /* reg offset shift */
2159 unsigned char iotype; /* io access style */
2160 unsigned char unused1;
2161 +#ifdef CONFIG_PPS_CLIENT_UART
2162 + int pps_source; /* PPS source ID */
2163 +#endif
2164
2165 #define UPIO_PORT (0)
2166 #define UPIO_HUB6 (1)
2167 @@ -280,7 +284,8 @@ struct uart_port {
2168 #define UPF_IOREMAP ((__force upf_t) (1 << 31))
2169
2170 #define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))
2171 -#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
2172 +#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY\
2173 + |UPF_HARDPPS_CD))
2174
2175 unsigned int mctrl; /* current modem ctrl settings */
2176 unsigned int timeout; /* character-based timeout */
2177 @@ -312,6 +317,10 @@ struct uart_state {
2178 struct uart_info *info;
2179 struct uart_port *port;
2180
2181 +#ifdef CONFIG_PPS_CLIENT_UART
2182 + struct pps_source_info pps_info;
2183 +#endif
2184 +
2185 struct mutex mutex;
2186 };
2187
2188 @@ -476,13 +485,22 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
2189 {
2190 struct uart_info *info = port->info;
2191
2192 - port->icount.dcd++;
2193 -
2194 -#ifdef CONFIG_HARD_PPS
2195 - if ((port->flags & UPF_HARDPPS_CD) && status)
2196 - hardpps();
2197 +#ifdef CONFIG_PPS_CLIENT_UART
2198 + if (port->flags & UPF_HARDPPS_CD) {
2199 + if (status) {
2200 + pps_event(port->pps_source, PPS_CAPTUREASSERT, port);
2201 + dev_dbg(port->dev, "PPS assert at %lu on source #%d\n",
2202 + jiffies, port->pps_source);
2203 + } else {
2204 + pps_event(port->pps_source, PPS_CAPTURECLEAR, port);
2205 + dev_dbg(port->dev, "PPS clear at %lu on source #%d\n",
2206 + jiffies, port->pps_source);
2207 + }
2208 + }
2209 #endif
2210
2211 + port->icount.dcd++;
2212 +
2213 if (info->flags & UIF_CHECK_CD) {
2214 if (status)
2215 wake_up_interruptible(&info->open_wait);
OpenWrt Source Repository