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