drivers/pps/generators/pps_gen_parport.c - third_party/kernel - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * pps_gen_parport.c -- kernel parallel port PPS signal generator
  *
  * Copyright (C) 2009   Alexander Gordeev <lasaine@lvk.cs.msu.su>
  */


 /*
  * 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");
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* pps_gen_parport.c -- kernel parallel port PPS signal generator
	*
	* Copyright (C) 2009 Alexander Gordeev <lasaine@lvk.cs.msu.su>
	*/


	/*
	* 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");