Hardware manual

Another interrupt is issued to tell the device driver to send yet another byte to the now empty transmit
buffer
3.
Thus we say that the serial port is interrupt driven. Each time the serial port issues an interrupt, the CPU sends
it another byte. Once a byte has been sent to the transmit buffer by the CPU, then the CPU is free to pursue
some other activities until it gets the next interrupt. The serial port transmits bits at a fixed rate which is
selected by the user (or an application program). It's sometimes called the baud rate. The serial port also adds
extra bits to each byte (start, stop and perhaps parity bits) so there are often 10 bits sent per byte. At a rate
(also called speed) of 19,200 bits per second (bps), there are thus 1,920 bytes/sec (and also 1,920
interrupts/sec).
Doing all this is a lot of work for the CPU. This is true for many reasons. First, just sending one 8-bit byte at a
time over a 32-bit data bus (or even 64-bit) is not a very efficient use of bus width. Also, there is a lot of
overhead in handing each interrupt. When the interrupt is received, the device driver only knows that
something caused an interrupt at the serial port but doesn't know that it's because a character has been sent.
The device driver has to make various checks to find out what happened. The same interrupt could mean that
a character was received, one of the control lines changed state, etc.
A major improvement has been the enlargement of the buffer size of the serial port from 1-byte to 16-bytes.
This means that when the CPU gets an interrupt it gives the serial port up to 16 new bytes to transmit. This is
fewer interrupts to service but data must still be transferred one byte at a time over a wide bus. The 16-byte
buffer is actually a FIFO (First In First Out) queue and is often called a FIFO. See FIFOs for details about the
FIFO along with a repeat of some of the above info.
3.2 Receiving
Receiving bytes by a serial port is similar to sending them only it's in the opposite direction. It's also interrupt
driven. For the obsolete type of serial port with 1-byte buffers, when a byte is fully received from the external
cable it goes into the 1-byte receive buffer. Then the port gives the CPU an interrupt to tell it to pick up that
byte so that the serial port will have room for storing the next byte which is currently being received. For
newer serial ports with 16-byte buffers, this interrupt (to fetch the bytes) may be sent after 14 bytes are in the
receive buffer. The CPU then stops what it was doing, runs the interrupt service routine, and picks up 14 to 16
bytes from the port. For an interrupt sent when the 14th byte has been received, there could be 16 bytes to get
if 2 more bytes have arrived since the interrupt. But if 3 more bytes should arrive (instead of 2), then the
16-byte buffer will overrun. It also may pick up less than 14 bytes by setting it up that way or due to timeouts.
See FIFOs for more details.
3.3 The Large Serial Buffers
We've talked about small 16-byte serial port hardware buffers but there are also much larger buffers in main
memory. When the CPU takes some bytes out of the receive buffer of the hardware, it puts them into a much
larger (say 8k-byte) receive buffer in main memory. Then a program that is getting bytes from the serial port
takes the bytes it's receiving out of that large buffer (using a "read" statement in the program).
A similar situation exists for bytes that are to be transmitted. When the CPU needs to fetch some bytes to be
transmitted it takes them out of a large (8k-byte) transmit buffer in main memory and puts them into the small
16-byte transmit buffer in the hardware. And when a program wants to send bytes out the serial port, it writes
them to this large transmit buffer.
Serial HOWTO
3.2 Receiving 10