/* * pps_gen_parport.c -- kernel parallel port PPS signal generator * * * Copyright (C) 2009 Alexander Gordeev * * 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 #include #include #include #include #include #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 timespec 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. getnstimeofday() 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... */ getnstimeofday(&ts1); expire_time = ktime_to_timespec(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 %ld.%09ld\n", ts1.tv_sec, ts1.tv_nsec); goto done; } /* busy loop until the time is right for an assert edge */ do { getnstimeofday(&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 { getnstimeofday(&ts2); } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim); /* unset the signal */ port->ops->write_control(port, NO_SIGNAL); getnstimeofday(&ts3); local_irq_restore(flags); /* update calibrated port write time */ dts = timespec_sub(ts3, ts2); dev->port_write_time = (dev->port_write_time + timespec_to_ns(&dts)) >> 1; done: /* update calibrated hrtimer error */ dts = timespec_sub(ts1, expire_time); delta = timespec_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 timespec a, b; unsigned long irq_flags; local_irq_save(irq_flags); getnstimeofday(&a); port->ops->write_control(port, NO_SIGNAL); getnstimeofday(&b); local_irq_restore(irq_flags); b = timespec_sub(b, a); acc += timespec_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 timespec ts; getnstimeofday(&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) { if (attached) { /* we already have a port */ return; } device.pardev = parport_register_device(port, KBUILD_MODNAME, NULL, NULL, NULL, PARPORT_FLAG_EXCL, &device); 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, .attach = parport_attach, .detach = parport_detach, }; /* 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 "); MODULE_DESCRIPTION(DRVDESC); MODULE_LICENSE("GPL");