1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * pps_gen_parport.c -- kernel parallel port PPS signal generator
4 *
5 * Copyright (C) 2009 Alexander Gordeev <lasaine@lvk.cs.msu.su>
6 */
7
8
9 /*
10 * TODO:
11 * fix issues when realtime clock is adjusted in a leap
12 */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/time.h>
20 #include <linux/hrtimer.h>
21 #include <linux/parport.h>
22
23 #define SIGNAL 0
24 #define NO_SIGNAL PARPORT_CONTROL_STROBE
25
26 /* module parameters */
27
28 #define SEND_DELAY_MAX 100000
29
30 static unsigned int send_delay = 30000;
31 MODULE_PARM_DESC(delay,
32 "Delay between setting and dropping the signal (ns)");
33 module_param_named(delay, send_delay, uint, 0);
34
35
36 #define SAFETY_INTERVAL 3000 /* set the hrtimer earlier for safety (ns) */
37
38 /* internal per port structure */
39 struct pps_generator_pp {
40 struct pardevice *pardev; /* parport device */
41 struct hrtimer timer;
42 long port_write_time; /* calibrated port write time (ns) */
43 };
44
45 static struct pps_generator_pp device = {
46 .pardev = NULL,
47 };
48
49 static int attached;
50
51 /* calibrated time between a hrtimer event and the reaction */
52 static long hrtimer_error = SAFETY_INTERVAL;
53
54 /* the kernel hrtimer event */
hrtimer_event(struct hrtimer * timer)55 static enum hrtimer_restart hrtimer_event(struct hrtimer *timer)
56 {
57 struct timespec64 expire_time, ts1, ts2, ts3, dts;
58 struct pps_generator_pp *dev;
59 struct parport *port;
60 long lim, delta;
61 unsigned long flags;
62
63 /* We have to disable interrupts here. The idea is to prevent
64 * other interrupts on the same processor to introduce random
65 * lags while polling the clock. ktime_get_real_ts64() takes <1us on
66 * most machines while other interrupt handlers can take much
67 * more potentially.
68 *
69 * NB: approx time with blocked interrupts =
70 * send_delay + 3 * SAFETY_INTERVAL
71 */
72 local_irq_save(flags);
73
74 /* first of all we get the time stamp... */
75 ktime_get_real_ts64(&ts1);
76 expire_time = ktime_to_timespec64(hrtimer_get_softexpires(timer));
77 dev = container_of(timer, struct pps_generator_pp, timer);
78 lim = NSEC_PER_SEC - send_delay - dev->port_write_time;
79
80 /* check if we are late */
81 if (expire_time.tv_sec != ts1.tv_sec || ts1.tv_nsec > lim) {
82 local_irq_restore(flags);
83 pr_err("we are late this time %ptSp\n", &ts1);
84 goto done;
85 }
86
87 /* busy loop until the time is right for an assert edge */
88 do {
89 ktime_get_real_ts64(&ts2);
90 } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
91
92 /* set the signal */
93 port = dev->pardev->port;
94 port->ops->write_control(port, SIGNAL);
95
96 /* busy loop until the time is right for a clear edge */
97 lim = NSEC_PER_SEC - dev->port_write_time;
98 do {
99 ktime_get_real_ts64(&ts2);
100 } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
101
102 /* unset the signal */
103 port->ops->write_control(port, NO_SIGNAL);
104
105 ktime_get_real_ts64(&ts3);
106
107 local_irq_restore(flags);
108
109 /* update calibrated port write time */
110 dts = timespec64_sub(ts3, ts2);
111 dev->port_write_time =
112 (dev->port_write_time + timespec64_to_ns(&dts)) >> 1;
113
114 done:
115 /* update calibrated hrtimer error */
116 dts = timespec64_sub(ts1, expire_time);
117 delta = timespec64_to_ns(&dts);
118 /* If the new error value is bigger then the old, use the new
119 * value, if not then slowly move towards the new value. This
120 * way it should be safe in bad conditions and efficient in
121 * good conditions.
122 */
123 if (delta >= hrtimer_error)
124 hrtimer_error = delta;
125 else
126 hrtimer_error = (3 * hrtimer_error + delta) >> 2;
127
128 /* update the hrtimer expire time */
129 hrtimer_set_expires(timer,
130 ktime_set(expire_time.tv_sec + 1,
131 NSEC_PER_SEC - (send_delay +
132 dev->port_write_time + SAFETY_INTERVAL +
133 2 * hrtimer_error)));
134
135 return HRTIMER_RESTART;
136 }
137
138 /* calibrate port write time */
139 #define PORT_NTESTS_SHIFT 5
calibrate_port(struct pps_generator_pp * dev)140 static void calibrate_port(struct pps_generator_pp *dev)
141 {
142 struct parport *port = dev->pardev->port;
143 int i;
144 long acc = 0;
145
146 for (i = 0; i < (1 << PORT_NTESTS_SHIFT); i++) {
147 struct timespec64 a, b;
148 unsigned long irq_flags;
149
150 local_irq_save(irq_flags);
151 ktime_get_real_ts64(&a);
152 port->ops->write_control(port, NO_SIGNAL);
153 ktime_get_real_ts64(&b);
154 local_irq_restore(irq_flags);
155
156 b = timespec64_sub(b, a);
157 acc += timespec64_to_ns(&b);
158 }
159
160 dev->port_write_time = acc >> PORT_NTESTS_SHIFT;
161 pr_info("port write takes %ldns\n", dev->port_write_time);
162 }
163
next_intr_time(struct pps_generator_pp * dev)164 static inline ktime_t next_intr_time(struct pps_generator_pp *dev)
165 {
166 struct timespec64 ts;
167
168 ktime_get_real_ts64(&ts);
169
170 return ktime_set(ts.tv_sec +
171 ((ts.tv_nsec > 990 * NSEC_PER_MSEC) ? 1 : 0),
172 NSEC_PER_SEC - (send_delay +
173 dev->port_write_time + 3 * SAFETY_INTERVAL));
174 }
175
parport_attach(struct parport * port)176 static void parport_attach(struct parport *port)
177 {
178 struct pardev_cb pps_cb;
179
180 if (send_delay > SEND_DELAY_MAX) {
181 pr_err("delay value should be not greater then %d\n", SEND_DELAY_MAX);
182 return;
183 }
184
185 if (attached) {
186 /* we already have a port */
187 return;
188 }
189
190 memset(&pps_cb, 0, sizeof(pps_cb));
191 pps_cb.private = &device;
192 pps_cb.flags = PARPORT_FLAG_EXCL;
193 device.pardev = parport_register_dev_model(port, KBUILD_MODNAME,
194 &pps_cb, 0);
195 if (!device.pardev) {
196 pr_err("couldn't register with %s\n", port->name);
197 return;
198 }
199
200 if (parport_claim_or_block(device.pardev) < 0) {
201 pr_err("couldn't claim %s\n", port->name);
202 goto err_unregister_dev;
203 }
204
205 pr_info("attached to %s\n", port->name);
206 attached = 1;
207
208 calibrate_port(&device);
209
210 hrtimer_setup(&device.timer, hrtimer_event, CLOCK_REALTIME, HRTIMER_MODE_ABS);
211 hrtimer_start(&device.timer, next_intr_time(&device), HRTIMER_MODE_ABS);
212
213 return;
214
215 err_unregister_dev:
216 parport_unregister_device(device.pardev);
217 }
218
parport_detach(struct parport * port)219 static void parport_detach(struct parport *port)
220 {
221 if (port->cad != device.pardev)
222 return; /* not our port */
223
224 hrtimer_cancel(&device.timer);
225 parport_release(device.pardev);
226 parport_unregister_device(device.pardev);
227 }
228
229 static struct parport_driver pps_gen_parport_driver = {
230 .name = KBUILD_MODNAME,
231 .match_port = parport_attach,
232 .detach = parport_detach,
233 };
234 module_parport_driver(pps_gen_parport_driver);
235
236 MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
237 MODULE_DESCRIPTION("parallel port PPS signal generator");
238 MODULE_LICENSE("GPL");
239