[linux-block.git] / drivers / pps / generators / pps_gen_parport.c

/*
 * pps_gen_parport.c -- kernel parallel port PPS signal generator
 *
 *
 * Copyright (C) 2009   Alexander Gordeev <lasaine@lvk.cs.msu.su>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


/*
 * TODO:
 * fix issues when realtime clock is adjusted in a leap
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/hrtimer.h>
#include <linux/parport.h>

#define DRVDESC "parallel port PPS signal generator"

#define SIGNAL		0
#define NO_SIGNAL	PARPORT_CONTROL_STROBE

/* module parameters */

#define SEND_DELAY_MAX		100000

static unsigned int send_delay = 30000;
MODULE_PARM_DESC(delay,
	"Delay between setting and dropping the signal (ns)");
module_param_named(delay, send_delay, uint, 0);


#define SAFETY_INTERVAL	3000	/* set the hrtimer earlier for safety (ns) */

/* internal per port structure */
struct pps_generator_pp {
	struct pardevice *pardev;	/* parport device */
	struct hrtimer timer;
	long port_write_time;		/* calibrated port write time (ns) */
};

static struct pps_generator_pp device = {
	.pardev = NULL,
};

static int attached;

/* calibrated time between a hrtimer event and the reaction */
static long hrtimer_error = SAFETY_INTERVAL;

/* the kernel hrtimer event */
static enum hrtimer_restart hrtimer_event(struct hrtimer *timer)
{
	struct timespec64 expire_time, ts1, ts2, ts3, dts;
	struct pps_generator_pp *dev;
	struct parport *port;
	long lim, delta;
	unsigned long flags;

	/* We have to disable interrupts here. The idea is to prevent
	 * other interrupts on the same processor to introduce random
	 * lags while polling the clock. ktime_get_real_ts64() takes <1us on
	 * most machines while other interrupt handlers can take much
	 * more potentially.
	 *
	 * NB: approx time with blocked interrupts =
	 * send_delay + 3 * SAFETY_INTERVAL
	 */
	local_irq_save(flags);

	/* first of all we get the time stamp... */
	ktime_get_real_ts64(&ts1);
	expire_time = ktime_to_timespec64(hrtimer_get_softexpires(timer));
	dev = container_of(timer, struct pps_generator_pp, timer);
	lim = NSEC_PER_SEC - send_delay - dev->port_write_time;

	/* check if we are late */
	if (expire_time.tv_sec != ts1.tv_sec || ts1.tv_nsec > lim) {
		local_irq_restore(flags);
		pr_err("we are late this time %lld.%09ld\n",
				(s64)ts1.tv_sec, ts1.tv_nsec);
		goto done;
	}

	/* busy loop until the time is right for an assert edge */
	do {
		ktime_get_real_ts64(&ts2);
	} while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);

	/* set the signal */
	port = dev->pardev->port;
	port->ops->write_control(port, SIGNAL);

	/* busy loop until the time is right for a clear edge */
	lim = NSEC_PER_SEC - dev->port_write_time;
	do {
		ktime_get_real_ts64(&ts2);
	} while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);

	/* unset the signal */
	port->ops->write_control(port, NO_SIGNAL);

	ktime_get_real_ts64(&ts3);

	local_irq_restore(flags);

	/* update calibrated port write time */
	dts = timespec64_sub(ts3, ts2);
	dev->port_write_time =
		(dev->port_write_time + timespec64_to_ns(&dts)) >> 1;

done:
	/* update calibrated hrtimer error */
	dts = timespec64_sub(ts1, expire_time);
	delta = timespec64_to_ns(&dts);
	/* If the new error value is bigger then the old, use the new
	 * value, if not then slowly move towards the new value. This
	 * way it should be safe in bad conditions and efficient in
	 * good conditions.
	 */
	if (delta >= hrtimer_error)
		hrtimer_error = delta;
	else
		hrtimer_error = (3 * hrtimer_error + delta) >> 2;

	/* update the hrtimer expire time */
	hrtimer_set_expires(timer,
			ktime_set(expire_time.tv_sec + 1,
				NSEC_PER_SEC - (send_delay +
				dev->port_write_time + SAFETY_INTERVAL +
				2 * hrtimer_error)));

	return HRTIMER_RESTART;
}

/* calibrate port write time */
#define PORT_NTESTS_SHIFT	5
static void calibrate_port(struct pps_generator_pp *dev)
{
	struct parport *port = dev->pardev->port;
	int i;
	long acc = 0;

	for (i = 0; i < (1 << PORT_NTESTS_SHIFT); i++) {
		struct timespec64 a, b;
		unsigned long irq_flags;

		local_irq_save(irq_flags);
		ktime_get_real_ts64(&a);
		port->ops->write_control(port, NO_SIGNAL);
		ktime_get_real_ts64(&b);
		local_irq_restore(irq_flags);

		b = timespec64_sub(b, a);
		acc += timespec64_to_ns(&b);
	}

	dev->port_write_time = acc >> PORT_NTESTS_SHIFT;
	pr_info("port write takes %ldns\n", dev->port_write_time);
}

static inline ktime_t next_intr_time(struct pps_generator_pp *dev)
{
	struct timespec64 ts;

	ktime_get_real_ts64(&ts);

	return ktime_set(ts.tv_sec +
			((ts.tv_nsec > 990 * NSEC_PER_MSEC) ? 1 : 0),
			NSEC_PER_SEC - (send_delay +
			dev->port_write_time + 3 * SAFETY_INTERVAL));
}

static void parport_attach(struct parport *port)
{
	struct pardev_cb pps_cb;

	if (attached) {
		/* we already have a port */
		return;
	}

	memset(&pps_cb, 0, sizeof(pps_cb));
	pps_cb.private = &device;
	pps_cb.flags = PARPORT_FLAG_EXCL;
	device.pardev = parport_register_dev_model(port, KBUILD_MODNAME,
						   &pps_cb, 0);
	if (!device.pardev) {
		pr_err("couldn't register with %s\n", port->name);
		return;
	}

	if (parport_claim_or_block(device.pardev) < 0) {
		pr_err("couldn't claim %s\n", port->name);
		goto err_unregister_dev;
	}

	pr_info("attached to %s\n", port->name);
	attached = 1;

	calibrate_port(&device);

	hrtimer_init(&device.timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
	device.timer.function = hrtimer_event;
	hrtimer_start(&device.timer, next_intr_time(&device), HRTIMER_MODE_ABS);

	return;

err_unregister_dev:
	parport_unregister_device(device.pardev);
}

static void parport_detach(struct parport *port)
{
	if (port->cad != device.pardev)
		return;	/* not our port */

	hrtimer_cancel(&device.timer);
	parport_release(device.pardev);
	parport_unregister_device(device.pardev);
}

static struct parport_driver pps_gen_parport_driver = {
	.name = KBUILD_MODNAME,
	.match_port = parport_attach,
	.detach = parport_detach,
	.devmodel = true,
};

/* module staff */

static int __init pps_gen_parport_init(void)
{
	int ret;

	pr_info(DRVDESC "\n");

	if (send_delay > SEND_DELAY_MAX) {
		pr_err("delay value should be not greater"
				" then %d\n", SEND_DELAY_MAX);
		return -EINVAL;
	}

	ret = parport_register_driver(&pps_gen_parport_driver);
	if (ret) {
		pr_err("unable to register with parport\n");
		return ret;
	}

	return  0;
}

static void __exit pps_gen_parport_exit(void)
{
	parport_unregister_driver(&pps_gen_parport_driver);
	pr_info("hrtimer avg error is %ldns\n", hrtimer_error);
}

module_init(pps_gen_parport_init);
module_exit(pps_gen_parport_exit);

MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
MODULE_DESCRIPTION(DRVDESC);
MODULE_LICENSE("GPL");
Commit	Line	Data
46b402a0 AG	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	{
28f3a488	73	struct timespec64 expire_time, ts1, ts2, ts3, dts;
46b402a0 AG	74	struct pps_generator_pp *dev;
	75	struct parport *port;
	76	long lim, delta;
	77	unsigned long flags;
	78
563558b2 AG	79	/* We have to disable interrupts here. The idea is to prevent
563558b2 AG	80	* other interrupts on the same processor to introduce random
28f3a488	81	* lags while polling the clock. ktime_get_real_ts64() takes <1us on
563558b2 AG	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	*/
46b402a0 AG	88	local_irq_save(flags);
	89
	90	/* first of all we get the time stamp... */
28f3a488 AB	91	ktime_get_real_ts64(&ts1);
28f3a488 AB	92	expire_time = ktime_to_timespec64(hrtimer_get_softexpires(timer));
46b402a0 AG	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);
28f3a488 AB	99	pr_err("we are late this time %lld.%09ld\n",
28f3a488 AB	100	(s64)ts1.tv_sec, ts1.tv_nsec);
46b402a0 AG	101	goto done;
	102	}
	103
	104	/* busy loop until the time is right for an assert edge */
	105	do {
28f3a488	106	ktime_get_real_ts64(&ts2);
46b402a0 AG	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 {
28f3a488	116	ktime_get_real_ts64(&ts2);
46b402a0 AG	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
28f3a488	122	ktime_get_real_ts64(&ts3);
46b402a0 AG	123
	124	local_irq_restore(flags);
	125
	126	/* update calibrated port write time */
28f3a488	127	dts = timespec64_sub(ts3, ts2);
46b402a0	128	dev->port_write_time =
28f3a488	129	(dev->port_write_time + timespec64_to_ns(&dts)) >> 1;
46b402a0 AG	130
	131	done:
	132	/* update calibrated hrtimer error */
28f3a488 AB	133	dts = timespec64_sub(ts1, expire_time);
28f3a488 AB	134	delta = timespec64_to_ns(&dts);
46b402a0 AG	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++) {
28f3a488	164	struct timespec64 a, b;
46b402a0 AG	165	unsigned long irq_flags;
	166
	167	local_irq_save(irq_flags);
28f3a488	168	ktime_get_real_ts64(&a);
46b402a0	169	port->ops->write_control(port, NO_SIGNAL);
28f3a488	170	ktime_get_real_ts64(&b);
46b402a0 AG	171	local_irq_restore(irq_flags);
46b402a0 AG	172
28f3a488 AB	173	b = timespec64_sub(b, a);
28f3a488 AB	174	acc += timespec64_to_ns(&b);
46b402a0 AG	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	{
28f3a488	183	struct timespec64 ts;
46b402a0	184
28f3a488	185	ktime_get_real_ts64(&ts);
46b402a0 AG	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	{
b857cacd SM	195	struct pardev_cb pps_cb;
b857cacd SM	196
46b402a0 AG	197	if (attached) {
	198	/* we already have a port */
	199	return;
	200	}
	201
b857cacd SM	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);
46b402a0 AG	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;
46b402a0 AG	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,
b857cacd	244	.match_port = parport_attach,
46b402a0	245	.detach = parport_detach,
b857cacd	246	.devmodel = true,
46b402a0 AG	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");