pps_gen_parport.c

  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
 30static unsigned int send_delay = 30000;
 31MODULE_PARM_DESC(delay,
 32	"Delay between setting and dropping the signal (ns)");
 33module_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 */
 39struct 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
 45static struct pps_generator_pp device = {
 46	.pardev = NULL,
 47};
 48
 49static int attached;
 50
 51/* calibrated time between a hrtimer event and the reaction */
 52static long hrtimer_error = SAFETY_INTERVAL;
 53
 54/* the kernel hrtimer event */
 55static 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
114done:
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
140static 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
164static 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
176static 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
215err_unregister_dev:
216	parport_unregister_device(device.pardev);
217}
218
219static 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
229static struct parport_driver pps_gen_parport_driver = {
230	.name = KBUILD_MODNAME,
231	.match_port = parport_attach,
232	.detach = parport_detach,
233};
234module_parport_driver(pps_gen_parport_driver);
235
236MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
237MODULE_DESCRIPTION("parallel port PPS signal generator");
238MODULE_LICENSE("GPL");