1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
43
44#define SEND_DELAY_MAX 100000
45
46static unsigned int send_delay = 30000;
47MODULE_PARM_DESC(delay,
48 "Delay between setting and dropping the signal (ns)");
49module_param_named(delay, send_delay, uint, 0);
50
51
52#define SAFETY_INTERVAL 3000
53
54
55struct pps_generator_pp {
56 struct pardevice *pardev;
57 struct hrtimer timer;
58 long port_write_time;
59};
60
61static struct pps_generator_pp device = {
62 .pardev = NULL,
63};
64
65static int attached;
66
67
68static long hrtimer_error = SAFETY_INTERVAL;
69
70
71static 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
80
81
82
83
84
85
86
87
88 local_irq_save(flags);
89
90
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
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
105 do {
106 ktime_get_real_ts64(&ts2);
107 } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
108
109
110 port = dev->pardev->port;
111 port->ops->write_control(port, SIGNAL);
112
113
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
120 port->ops->write_control(port, NO_SIGNAL);
121
122 ktime_get_real_ts64(&ts3);
123
124 local_irq_restore(flags);
125
126
127 dts = timespec64_sub(ts3, ts2);
128 dev->port_write_time =
129 (dev->port_write_time + timespec64_to_ns(&dts)) >> 1;
130
131done:
132
133 dts = timespec64_sub(ts1, expire_time);
134 delta = timespec64_to_ns(&dts);
135
136
137
138
139
140 if (delta >= hrtimer_error)
141 hrtimer_error = delta;
142 else
143 hrtimer_error = (3 * hrtimer_error + delta) >> 2;
144
145
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
156#define PORT_NTESTS_SHIFT 5
157static 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
181static 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
193static void parport_attach(struct parport *port)
194{
195 struct pardev_cb pps_cb;
196
197 if (attached) {
198
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
228err_unregister_dev:
229 parport_unregister_device(device.pardev);
230}
231
232static void parport_detach(struct parport *port)
233{
234 if (port->cad != device.pardev)
235 return;
236
237 hrtimer_cancel(&device.timer);
238 parport_release(device.pardev);
239 parport_unregister_device(device.pardev);
240}
241
242static 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
250
251static 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
272static 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
278module_init(pps_gen_parport_init);
279module_exit(pps_gen_parport_exit);
280
281MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
282MODULE_DESCRIPTION(DRVDESC);
283MODULE_LICENSE("GPL");
284