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