I am working on a Linux kernel module that registers a callback for interrupts that come from a custom-made board and puts the received data in a queue behind a char device interface to be processed by an application. This module needs to constantly monitor and measure the interrupts and data that comes from the board even if no interrupt comes from the board, so it has another callback that triggers according to time.
Current implementation uses RTC interrupt as a constant timer source. I disable kernel RTC drivers (CONFIG_RTC_DRV_CMOS) and request for IRQ 8 and hook the timer callback as RTC interrupt handler. Interrupts are generated every second from RTC chip.
The problem is we have to lose some of Linux's ability to manage time in this way, because only one of rtc-cmos or the board module can be loaded at once (and obviously we've chosen the board module).
Target architecture is i386 PC.
I'm not a kernel developer and so don't have a big picture on kernel module development, but I'm trying to find my way and these are nearest thing to solution that come to my mind:
- Somehow share the IRQ 8 between both modules (maybe like
request_irq(8, rtc_handler, IRQF_SHARED, rtc_handler)?) or chainload IRQ handlers. - Finding another way to hook a handler from a kernel module to RTC interrupt, rather than registering for IRQ 8.
- Finding another source of 1-second timer events that can be used from within a kernel module, maybe there is a standard kernel API for that, I don't know.
I suppose there might be a simple and standard way to do this and I would be glad If anyone would comment on either of these solutions or suggest others.