xref: /linux/drivers/pps/generators/pps_gen_parport.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
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 %lld.%09ld\n",
84 				(s64)ts1.tv_sec, ts1.tv_nsec);
85 		goto done;
86 	}
87 
88 	/* busy loop until the time is right for an assert edge */
89 	do {
90 		ktime_get_real_ts64(&ts2);
91 	} while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
92 
93 	/* set the signal */
94 	port = dev->pardev->port;
95 	port->ops->write_control(port, SIGNAL);
96 
97 	/* busy loop until the time is right for a clear edge */
98 	lim = NSEC_PER_SEC - dev->port_write_time;
99 	do {
100 		ktime_get_real_ts64(&ts2);
101 	} while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
102 
103 	/* unset the signal */
104 	port->ops->write_control(port, NO_SIGNAL);
105 
106 	ktime_get_real_ts64(&ts3);
107 
108 	local_irq_restore(flags);
109 
110 	/* update calibrated port write time */
111 	dts = timespec64_sub(ts3, ts2);
112 	dev->port_write_time =
113 		(dev->port_write_time + timespec64_to_ns(&dts)) >> 1;
114 
115 done:
116 	/* update calibrated hrtimer error */
117 	dts = timespec64_sub(ts1, expire_time);
118 	delta = timespec64_to_ns(&dts);
119 	/* If the new error value is bigger then the old, use the new
120 	 * value, if not then slowly move towards the new value. This
121 	 * way it should be safe in bad conditions and efficient in
122 	 * good conditions.
123 	 */
124 	if (delta >= hrtimer_error)
125 		hrtimer_error = delta;
126 	else
127 		hrtimer_error = (3 * hrtimer_error + delta) >> 2;
128 
129 	/* update the hrtimer expire time */
130 	hrtimer_set_expires(timer,
131 			ktime_set(expire_time.tv_sec + 1,
132 				NSEC_PER_SEC - (send_delay +
133 				dev->port_write_time + SAFETY_INTERVAL +
134 				2 * hrtimer_error)));
135 
136 	return HRTIMER_RESTART;
137 }
138 
139 /* calibrate port write time */
140 #define PORT_NTESTS_SHIFT	5
calibrate_port(struct pps_generator_pp * dev)141 static void calibrate_port(struct pps_generator_pp *dev)
142 {
143 	struct parport *port = dev->pardev->port;
144 	int i;
145 	long acc = 0;
146 
147 	for (i = 0; i < (1 << PORT_NTESTS_SHIFT); i++) {
148 		struct timespec64 a, b;
149 		unsigned long irq_flags;
150 
151 		local_irq_save(irq_flags);
152 		ktime_get_real_ts64(&a);
153 		port->ops->write_control(port, NO_SIGNAL);
154 		ktime_get_real_ts64(&b);
155 		local_irq_restore(irq_flags);
156 
157 		b = timespec64_sub(b, a);
158 		acc += timespec64_to_ns(&b);
159 	}
160 
161 	dev->port_write_time = acc >> PORT_NTESTS_SHIFT;
162 	pr_info("port write takes %ldns\n", dev->port_write_time);
163 }
164 
next_intr_time(struct pps_generator_pp * dev)165 static inline ktime_t next_intr_time(struct pps_generator_pp *dev)
166 {
167 	struct timespec64 ts;
168 
169 	ktime_get_real_ts64(&ts);
170 
171 	return ktime_set(ts.tv_sec +
172 			((ts.tv_nsec > 990 * NSEC_PER_MSEC) ? 1 : 0),
173 			NSEC_PER_SEC - (send_delay +
174 			dev->port_write_time + 3 * SAFETY_INTERVAL));
175 }
176 
parport_attach(struct parport * port)177 static void parport_attach(struct parport *port)
178 {
179 	struct pardev_cb pps_cb;
180 
181 	if (send_delay > SEND_DELAY_MAX) {
182 		pr_err("delay value should be not greater then %d\n", SEND_DELAY_MAX);
183 		return;
184 	}
185 
186 	if (attached) {
187 		/* we already have a port */
188 		return;
189 	}
190 
191 	memset(&pps_cb, 0, sizeof(pps_cb));
192 	pps_cb.private = &device;
193 	pps_cb.flags = PARPORT_FLAG_EXCL;
194 	device.pardev = parport_register_dev_model(port, KBUILD_MODNAME,
195 						   &pps_cb, 0);
196 	if (!device.pardev) {
197 		pr_err("couldn't register with %s\n", port->name);
198 		return;
199 	}
200 
201 	if (parport_claim_or_block(device.pardev) < 0) {
202 		pr_err("couldn't claim %s\n", port->name);
203 		goto err_unregister_dev;
204 	}
205 
206 	pr_info("attached to %s\n", port->name);
207 	attached = 1;
208 
209 	calibrate_port(&device);
210 
211 	hrtimer_init(&device.timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
212 	device.timer.function = hrtimer_event;
213 	hrtimer_start(&device.timer, next_intr_time(&device), HRTIMER_MODE_ABS);
214 
215 	return;
216 
217 err_unregister_dev:
218 	parport_unregister_device(device.pardev);
219 }
220 
parport_detach(struct parport * port)221 static void parport_detach(struct parport *port)
222 {
223 	if (port->cad != device.pardev)
224 		return;	/* not our port */
225 
226 	hrtimer_cancel(&device.timer);
227 	parport_release(device.pardev);
228 	parport_unregister_device(device.pardev);
229 }
230 
231 static struct parport_driver pps_gen_parport_driver = {
232 	.name = KBUILD_MODNAME,
233 	.match_port = parport_attach,
234 	.detach = parport_detach,
235 };
236 module_parport_driver(pps_gen_parport_driver);
237 
238 MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
239 MODULE_DESCRIPTION("parallel port PPS signal generator");
240 MODULE_LICENSE("GPL");
241