questions of a kernel-newbie, simple ISA driver

questions of a kernel-newbie, simple ISA driver

[Timothy Hamlin]

Hello kernel wizards,

I'm in the process of developing a simple device driver for a board my
research group has been using for some time in our lightning mapping
system.  I've made progress understanding how to get kernel modules
written, but have some questions -- this is my first kernel module of any
real use.  Here's a brief description of the hardware:

This is an ISA board that has a settable base address, usually 0x230.
The board has a 16bit wide FIFO (baseAddr + 4) that is 32k deep.  As data
flows in, the data accumulates in the FIFO.  When the FIFO is 1/2 full a
flag is set in a status register (baseAddr + 1).  The driver needs to read
1/2 of the FIFO and make the data available in a /dev entry.  So far I've
got the polling for the flag working, and can get the data out of the
FIFO.  Interrupts are also possible, but I thought it best to start by
getting the polling function to work, as I will need to re-program the
firmware to enable interrupts.

The first question is how to deal with the data.  The main reason for
switching to a kernel module is that a user-side driver (which is what
I've used so far) can not always keep up with the data rate, as the FIFO
fills potentially 100 or so times/second.  My first thought is to keep a
larger buffer for the data, so that a user program can have lesser time
constraints when it comes to getting a hold of the data.

I guess it would flow something like this:

Driver polls for the 1/2 full FIFO flag, when found transfer 16k words out
of the FIFO and place this in a larger buffer, say 320k or something.
How would I maintain this buffer?  Reads to the /dev entry need to be able
to get a continuous stream from the device, how do I keep the buffer both
filling, and being read out at the same time?  Should I make the buffer a
FIFO as well?  How?  How do I keep track of what has been read from the
buffer, so that subsequent reads get new data, not data that is lower down
in the buffer?  Can I allow multiple processes to be reading from this
/dev entry without loosing data to any of them?

Also, when I read for a device like a serial port I can just do cat
/dev/ttyS0 and watch the stream coming in.  So far in my driver, a read
performs one operation, outputs whatever, and then stops.  So a cat of my
device only transfers the current data, and then just sits there.  How do
I keep that steam going so that a cat will continually update?

One more.  What's the best way to poll for the 1/2 full flag?  Right now
I'm using a queue_task(), which gets called on every timer interrupt, is
this reasonable, or is there a better way to do it?

TIA for any suggestions, or any pointers to simple skeleton sources that
might help give my foolish mind a little direction.

^t
  --------------------------------------------------------------------------
   Timothy Hamlin ** thamlin at nmt dot edu ** http://www.nmt.edu/~thamlin/
  --------------------------------------------------------------------------
       Department of Physics, NMIMT, Socorro NM 87801
       Office, Workman 251: 835-5137  Lab, Workman 246
       Home,   Polvadera  : 835-0805
       "Linux, the choice of a GNU generation."

Re: questions of a kernel-newbie, simple ISA driver

[Timur Tabi]

Timothy Hamlin wrote:

 > Driver polls for the 1/2 full FIFO flag, when found transfer 16k words out
 > of the FIFO and place this in a larger buffer, say 320k or something.

The driver should instead poll the device at regular, adjustable intervals, 
and read ALL the data it can at each interval.  Assuming the hardware allows 
that, of couse.

 > How would I maintain this buffer?  Reads to the /dev entry need to be able
 > to get a continuous stream from the device, how do I keep the buffer both
 > filling, and being read out at the same time?  Should I make the buffer a
 > FIFO as well?  How?  How do I keep track of what has been read from the
 > buffer, so that subsequent reads get new data, not data that is lower down
 > in the buffer?

This is a basic, first-year computer science question.  Just use a circular 
buffer.  You can get the algorithm from any CS book.

 >  Can I allow multiple processes to be reading from this
 > /dev entry without loosing data to any of them?

Sure, just use one circular buffer per process.

 > Also, when I read for a device like a serial port I can just do cat
 > /dev/ttyS0 and watch the stream coming in.  So far in my driver, a read
 > performs one operation, outputs whatever, and then stops.  So a cat of my
 > device only transfers the current data, and then just sits there.  How do
 > I keep that steam going so that a cat will continually update?

Increase the rate at which you read the hardware FIFO.  Or perhaps, use the 
reads to your /dev device as a trigger to get more data from the HW.