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