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