pps_gen_parport.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  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. * TODO:
  9. * fix issues when realtime clock is adjusted in a leap
  10. */
  11. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/init.h>
  15. #include <linux/time.h>
  16. #include <linux/hrtimer.h>
  17. #include <linux/parport.h>
  18. #define DRVDESC "parallel port PPS signal generator"
  19. #define SIGNAL 0
  20. #define NO_SIGNAL PARPORT_CONTROL_STROBE
  21. /* module parameters */
  22. #define SEND_DELAY_MAX 100000
  23. static unsigned int send_delay = 30000;
  24. MODULE_PARM_DESC(delay,
  25. "Delay between setting and dropping the signal (ns)");
  26. module_param_named(delay, send_delay, uint, 0);
  27. #define SAFETY_INTERVAL 3000 /* set the hrtimer earlier for safety (ns) */
  28. /* internal per port structure */
  29. struct pps_generator_pp {
  30. struct pardevice *pardev; /* parport device */
  31. struct hrtimer timer;
  32. long port_write_time; /* calibrated port write time (ns) */
  33. };
  34. static struct pps_generator_pp device = {
  35. .pardev = NULL,
  36. };
  37. static int attached;
  38. /* calibrated time between a hrtimer event and the reaction */
  39. static long hrtimer_error = SAFETY_INTERVAL;
  40. /* the kernel hrtimer event */
  41. static enum hrtimer_restart hrtimer_event(struct hrtimer *timer)
  42. {
  43. struct timespec64 expire_time, ts1, ts2, ts3, dts;
  44. struct pps_generator_pp *dev;
  45. struct parport *port;
  46. long lim, delta;
  47. unsigned long flags;
  48. /* We have to disable interrupts here. The idea is to prevent
  49. * other interrupts on the same processor to introduce random
  50. * lags while polling the clock. ktime_get_real_ts64() takes <1us on
  51. * most machines while other interrupt handlers can take much
  52. * more potentially.
  53. *
  54. * NB: approx time with blocked interrupts =
  55. * send_delay + 3 * SAFETY_INTERVAL
  56. */
  57. local_irq_save(flags);
  58. /* first of all we get the time stamp... */
  59. ktime_get_real_ts64(&ts1);
  60. expire_time = ktime_to_timespec64(hrtimer_get_softexpires(timer));
  61. dev = container_of(timer, struct pps_generator_pp, timer);
  62. lim = NSEC_PER_SEC - send_delay - dev->port_write_time;
  63. /* check if we are late */
  64. if (expire_time.tv_sec != ts1.tv_sec || ts1.tv_nsec > lim) {
  65. local_irq_restore(flags);
  66. pr_err("we are late this time %lld.%09ld\n",
  67. (s64)ts1.tv_sec, ts1.tv_nsec);
  68. goto done;
  69. }
  70. /* busy loop until the time is right for an assert edge */
  71. do {
  72. ktime_get_real_ts64(&ts2);
  73. } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
  74. /* set the signal */
  75. port = dev->pardev->port;
  76. port->ops->write_control(port, SIGNAL);
  77. /* busy loop until the time is right for a clear edge */
  78. lim = NSEC_PER_SEC - dev->port_write_time;
  79. do {
  80. ktime_get_real_ts64(&ts2);
  81. } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
  82. /* unset the signal */
  83. port->ops->write_control(port, NO_SIGNAL);
  84. ktime_get_real_ts64(&ts3);
  85. local_irq_restore(flags);
  86. /* update calibrated port write time */
  87. dts = timespec64_sub(ts3, ts2);
  88. dev->port_write_time =
  89. (dev->port_write_time + timespec64_to_ns(&dts)) >> 1;
  90. done:
  91. /* update calibrated hrtimer error */
  92. dts = timespec64_sub(ts1, expire_time);
  93. delta = timespec64_to_ns(&dts);
  94. /* If the new error value is bigger then the old, use the new
  95. * value, if not then slowly move towards the new value. This
  96. * way it should be safe in bad conditions and efficient in
  97. * good conditions.
  98. */
  99. if (delta >= hrtimer_error)
  100. hrtimer_error = delta;
  101. else
  102. hrtimer_error = (3 * hrtimer_error + delta) >> 2;
  103. /* update the hrtimer expire time */
  104. hrtimer_set_expires(timer,
  105. ktime_set(expire_time.tv_sec + 1,
  106. NSEC_PER_SEC - (send_delay +
  107. dev->port_write_time + SAFETY_INTERVAL +
  108. 2 * hrtimer_error)));
  109. return HRTIMER_RESTART;
  110. }
  111. /* calibrate port write time */
  112. #define PORT_NTESTS_SHIFT 5
  113. static void calibrate_port(struct pps_generator_pp *dev)
  114. {
  115. struct parport *port = dev->pardev->port;
  116. int i;
  117. long acc = 0;
  118. for (i = 0; i < (1 << PORT_NTESTS_SHIFT); i++) {
  119. struct timespec64 a, b;
  120. unsigned long irq_flags;
  121. local_irq_save(irq_flags);
  122. ktime_get_real_ts64(&a);
  123. port->ops->write_control(port, NO_SIGNAL);
  124. ktime_get_real_ts64(&b);
  125. local_irq_restore(irq_flags);
  126. b = timespec64_sub(b, a);
  127. acc += timespec64_to_ns(&b);
  128. }
  129. dev->port_write_time = acc >> PORT_NTESTS_SHIFT;
  130. pr_info("port write takes %ldns\n", dev->port_write_time);
  131. }
  132. static inline ktime_t next_intr_time(struct pps_generator_pp *dev)
  133. {
  134. struct timespec64 ts;
  135. ktime_get_real_ts64(&ts);
  136. return ktime_set(ts.tv_sec +
  137. ((ts.tv_nsec > 990 * NSEC_PER_MSEC) ? 1 : 0),
  138. NSEC_PER_SEC - (send_delay +
  139. dev->port_write_time + 3 * SAFETY_INTERVAL));
  140. }
  141. static void parport_attach(struct parport *port)
  142. {
  143. struct pardev_cb pps_cb;
  144. if (attached) {
  145. /* we already have a port */
  146. return;
  147. }
  148. memset(&pps_cb, 0, sizeof(pps_cb));
  149. pps_cb.private = &device;
  150. pps_cb.flags = PARPORT_FLAG_EXCL;
  151. device.pardev = parport_register_dev_model(port, KBUILD_MODNAME,
  152. &pps_cb, 0);
  153. if (!device.pardev) {
  154. pr_err("couldn't register with %s\n", port->name);
  155. return;
  156. }
  157. if (parport_claim_or_block(device.pardev) < 0) {
  158. pr_err("couldn't claim %s\n", port->name);
  159. goto err_unregister_dev;
  160. }
  161. pr_info("attached to %s\n", port->name);
  162. attached = 1;
  163. calibrate_port(&device);
  164. hrtimer_init(&device.timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
  165. device.timer.function = hrtimer_event;
  166. hrtimer_start(&device.timer, next_intr_time(&device), HRTIMER_MODE_ABS);
  167. return;
  168. err_unregister_dev:
  169. parport_unregister_device(device.pardev);
  170. }
  171. static void parport_detach(struct parport *port)
  172. {
  173. if (port->cad != device.pardev)
  174. return; /* not our port */
  175. hrtimer_cancel(&device.timer);
  176. parport_release(device.pardev);
  177. parport_unregister_device(device.pardev);
  178. }
  179. static struct parport_driver pps_gen_parport_driver = {
  180. .name = KBUILD_MODNAME,
  181. .match_port = parport_attach,
  182. .detach = parport_detach,
  183. .devmodel = true,
  184. };
  185. /* module staff */
  186. static int __init pps_gen_parport_init(void)
  187. {
  188. int ret;
  189. pr_info(DRVDESC "\n");
  190. if (send_delay > SEND_DELAY_MAX) {
  191. pr_err("delay value should be not greater"
  192. " then %d\n", SEND_DELAY_MAX);
  193. return -EINVAL;
  194. }
  195. ret = parport_register_driver(&pps_gen_parport_driver);
  196. if (ret) {
  197. pr_err("unable to register with parport\n");
  198. return ret;
  199. }
  200. return 0;
  201. }
  202. static void __exit pps_gen_parport_exit(void)
  203. {
  204. parport_unregister_driver(&pps_gen_parport_driver);
  205. pr_info("hrtimer avg error is %ldns\n", hrtimer_error);
  206. }
  207. module_init(pps_gen_parport_init);
  208. module_exit(pps_gen_parport_exit);
  209. MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
  210. MODULE_DESCRIPTION(DRVDESC);
  211. MODULE_LICENSE("GPL");