release 1.1a Sat Nov 11, 1989

This is an unofficial release as I'm not the original author
of this async driver.

Uwe Doering <fas@geminix.in-berlin.de>
Billstedter Pfad 17 b
13591 Berlin
Germany

New Features:

	Added a third minor tty device number for every physical
	port. See description preceding the asyopen function in
	asy.c. Changed the behavior of ttyxx, too.

	Added output hardware handshake support for DSR. Now you
	can do handshake with CTS, DSR or both. Input hardware
	handshake is on if you use at least one of the output
	handshake signals.

	More flexible support of additional interrupt registers
	on mux boards. This is fully configurable now.

	Added support for the CREAD flag. If not set, receiver
	interrupts are still serviced, but the received characters
	are simply thrown away. This is not as elegant as disabeling
	the interrupts themselves, but with the already existing
	driver it was the easiest way, and the most new-bugs-preventing,
	too.

	Added a lot of comments to the source so that the curious
	user can understand why and how things are done.


Bug Fixes:

	The hang-up-on-last-close flag (HUPCL) was ignored. DTR
	was asserted regardless of this flag.

	Made the detection of CTS and DCD more bullet-proof.
	Especially because between a close and the next open of
	a line, where interrupts are ignored, the software copys of
	CTS and DCD must be set up propperly in the asyopen function
	or the tty line would be blocked under certain circum-
	stances. For similar reasons, there is also a setup in the
	asyparam function.

	Rewrote the input character processing function to work
	according to the TERMIO(7) man page.

	Changed the behavior of BREAK generation to let the
	transmitter drain before TX is set to low.

	Changed line hangup procedure so that the closing
	process returns immediately and doesn't sleep during
	the hangup delay/time. Instead, if an other process tries
	to open the line while hangup is still in progress, this
	process will sleep until hangup is competed.

	With DOS Merge, on MicroPort V/386 3.0e the linker was
	missing the function `init8250'. Reengineered this from
	a disassembler listing of MicroPort's original driver and
	modified it to work with the NS16550A 16-byte FIFO. This
	funktion was added simply to be able to link the kernel.
	DOS Merge's virtual COM ports are still unusable with this
	release, though. To include this function, add a `-DMERGE'
	to the CFLAGS line in your makefile.

	Made a lot of other corrections and enhancements in both
	speed and functionallity. As a result of all my effords
	I think this driver is slightly faster, more versatile
	and much more stable than the original release.

------------------------------------------------------------
	
release 1.1b Sat Nov 25, 1989

New Features:

	Changed the minor device number scheme again.
	There are now two main groups: The unblocked open
	and the blocked open. Every group has four sub-modes
	and an additional hardware handshake flag. All this
	is coded in the higher four bits of the minor device
	number. Because of this, the maximum of 32 ports was
	reduced to 16 ports so that the port number fits into
	the remaining lower four bits of the minor device number.
	32 dumb ports in a single machine would have been overkill
	anyway. For more details refer to the description in the
	README file.

------------------------------------------------------------
	
release 2.00 Mon Nov 27, 1989

As this release differs so much from the original version I got,
I now declare this as independant from the original author
Jim Murray. This allows me to introduce new release levels
without wondering whether they will collide with Jim's releases.
Of course many credits to Jim for writing this software in the
first place. Without his driver as a base I never would have
been able to do such kernel driver development.

Bug Fixes:

	If there were glitches on the hardware handshake lines
	and the DCD line a getty on this port would sometimes
	hang and become an immortal process. I think this was
	because the output buffer wasn't flushed properly
	on carrier loss. I hope I fixed this now. We'll see.

------------------------------------------------------------
	
release 2.01 Tue Nov 28, 1989

Did some cleanup in the source code.

I splitted the driver into two parts: The driver itself and
the file `space.c'.
`space.c' contains all data structures necessary to configure
the driver and is compiled at kernel link time. Therefore, if you
change your serial card configuration you simply change `space.c'
directly in the link kit directory and relink the kernel. No
driver recompilation or installation is necessary for this.
But note that whenever you use `make install' your setup in
the link kit directory is overwritten by the original `space.c'
file. Therefore, you should copy your new `space.c' back to
the source directory when you are finished with the configuration.

Renamed the package to `FAS Final Async Solution'. The following
files have been renamed:
	asy.c          -> fas.c
	asy.h          -> fas.h
	asy_conf-xxxxx -> space-xxxxx

ISC 386/ix is supported now. There are separate makefiles
for uPort and ISC to cope with the differences in link kit
installation.

Bug Fixes:

	`getty' still hung sometimes on a line with hardware
	handshake. Tried to fix it this time.

------------------------------------------------------------
	
release 2.02 Thu Nov 30, 1989

Abandoned the distinction between space-xxxxx files with
and without hardware flow control because this is selected
by the minor device number now.

Bug Fixes:

	Set the high and low water marks for hardware input flow
	control to higher values than software flow control. This
	gives precedence to software flow control if both methods
	are used. These marks are self-adjusting and don't need to
	be changed if some flavor of UNIX has a different buffer
	size than the standard 256 characters. Before this change
	concurrent use of both flow controls could cause trouble
	with some high-speed modems. This is fixed now.

	A flush read or write buffer request now also clears the
	receiver or transmitter FIFO, respectively. An ioctl
	call with a TCSETA* command clears the FIFOs, too.

------------------------------------------------------------
	
release 2.03 Fri Dec 01, 1989

Wrote an installation guide. The driver should be quite
easy to install now.

Added tty node configuration files for ISC.

Hardware input flow control is bound now to the level of the
receiver ring buffer instead of the UNIX input buffer. This
has the advantage that buffer size and trigger levels are
defined in the driver and therefore can be varied as needed.

New Features:

	Added a boot time status message that shows the init
	state of each port. This tells you immediately what
	ports are found and initted by the driver. Useful to
	determine hardware configuration problems. Look at
	the description in the README file. Thanks to
	Kritt Gierlewsen (kritt@einoed.UUCP) for this proposal.

------------------------------------------------------------
	
release 2.04 Thu Dec 07, 1989

Did some cleanup in the source.

Removed the FIFO clear from the ioctl function. We don't want
to do things there that aren't in the book.

An ioctl call that switches off the CLOCAL flag will create
a SIGHUP signal if the carrier is actually missing at this
time.

Every device is tested now quite thoroughly during initialization.
If the test fails the corresponding device keeps unconfigured.

------------------------------------------------------------
	
release 2.05 Sat Jan 13, 1990

This is the first public release of the FAS driver.

Special thanks to the sysops of my test sites, Axel Fischer
(fischer@utower.UUCP) and Kritt Gierlewsen (kritt@einoed.UUCP).

FAS is now an independant driver with its own driver name (`fas'),
major device number, link kit directory and other things necessary
for a driver. The original asy driver may or may not be linked
with the kernel. You only need it if you want to access some
serial devices via the virtual COM ports of the DOS emulator
(DosMerge or VP/ix) because the FAS driver doesn't have this
(really vendor dependant) feature.

The default prefix for tty device node names is `ttyF' now.
This prevents mix-ups with the device names of the original
asy driver.

Dropped the SYSV/AT support. I couldn't test the driver
for several release generations on uPort SYSV/AT, and because
there are not very much systems left with that flavor of UNIX
it doesn't make sense to try to maintain compatibility with it.
If someone really wants to use this driver on a 286 he has
to port it himself.

Improved the transmitter FIFO fill procedure. Now it will try
harder to fill the FIFO as much as possible to cut down on
transmitter interrupts.

Software input flow control (XON/XOFF) is controlled by the driver now.
It is bound to the level of the receiver ring buffer (as is hardware
flow control). As usual, it can be switched on and off by the
IXOFF flag in the termio(7) structure.

Changed and speeded up the ring buffer -> unix buffer processing.

For ISC, the getty lines for the inittab file are installed
by the makefile now.

The conditional compilation of the function `init8250' (for
DosMerge) is now controlled by a define in `fas.h'. The compiler
switch `-DMERGE' is not used any more.

Improved the documentation.

The signals used for modem control and hardware flow control are
fully configurable in the `space.c' file now. Look at `fas.h' for
possible macros and combinations.

There are some new modes for hardware flow control, for instance
HO_CTS_ON_DSR. This means that CTS is only looked at if DSR is on.
If DSR is off output is possible regardless of CTS. The underlying
assumption here is that we can expect proper handshake handling
only from devices that are in the ready state (indicated by DSR).
As a spin-off the problem with the hanging getty on lines with
turned-off terminals (mentioned in earlier releases) should be
gone if you use this new mode.

If the XCLUDE-Flag is availabe (SYSV 3.2 because of Xenix
compatibility) exclusive open of a device is possible.

The default size of the input ring buffer is now 5000 bytes.
This makes streaming input more likely even on loaded systems.

Bug Fixes:

	The task state busy flag wasn't reset in some rare cases.
	This could cause processes to become immortal while waiting
	for the busy flag.

	Under some special conditions an ioctl call with a TCSETA?
	command could corrupt the last character in the transmitter
	shift register. This is fixed now.

	More fixing of the busy flag handling was necessary.
	Co-ordinating several delayed tasks controlling this flag
	is kind of tricky.

	After a TCSETA* ioctl command we disable the transmitter
	for 2 sec (measured from the last transmitted character)
	if the character format and/or speed has changed. This
	gives the receiving side some time to do the same changes.
	This is kind of experimental. There may be applications that
	suffer from this delay. You may change the #define ADAPT_TIME
	in `fas.h' to a smaller value.

------------------------------------------------------------
	
release 2.06 Fri Mar 16, 1990

This should have been patch #3 for release 2.05, but there are
so many changes now that I decided to make it a new release.
Therefore, some of the changes are described in the 2.05 release
notes above but were never released to the public.

New Features:

	There is a transmitter ring buffer now to make the output
	less system load dependent. This really speeds things up
	because the transmitter FIFO gets filled with more characters
	at once. The buffer size depends on the actual baud rate to
	prevent long output buffer drains at low speeds.

	There are also bigger input buffers to make FAS more competitive
	against "intelligent" cards.

	Lots of speed improvements and many small changes.

Bug Fixes:

	Fixed input/output buffer flush on carrier loss while close
	is waiting for the output to drain.

------------------------------------------------------------
	
release 2.07 Tue Sep 18, 1990

This is a major redesign of the previous release. I put most of the
time consuming tasks in one function that is invoked asynchronously
by timeout calls. Inside this function most of the code runs at
a lower system priority level (spl5) than the interrupts. That
means that during character processing tty interrupts are allowed.
This is the main key to operation at 38400 bps on multiple ports
at the same time which is possible now with this release.

New Features:

	FAS supports the VP/ix DOS emulator!
	Now you can throw out the vendor's original driver even
	if you like to have a serial mouse or modem access in DOS.
	Read the paragraph about VP/ix in the README file.

	The Intel i82510 port chip is supported. It has separate
	4-character FIFOs for input and output. Although the
	NS16550A is much better this chip is your second choice
	if you can't get your hands on the National chips.
	Thanks to Christian Seyb (cs@gold.UUCP) for sending me
	patches and the necessary documentation for the Intel
	chips.

	There is an init sequence in `space.c'. You can put any
	number of address-data pairs in a null terminated array
	to program your serial card or other hardware before
	FAS makes the first access to the ports. AST 4-port cards,
	for instance, have an additional port that needs to be
	written to with a certain bit pattern to allow shared
	interrupts. If you need to read a port to achieve the
	setting or resetting of flags as a side effect, this
	is possible, too.

	ESIX is officially supported now.

	SCO UNIX is officially supported, too. FAS needs to be
	compiled with the command line flag `-DSCO'. The makefile
	for SCO takes care of that. Thanks to Walter Mecky
	(walter@mecky.systemware.de) and Frank Simon
	(terra@sol.north.de) for helping me in making the necessary
	changes for SCO UNIX.

	SCO Xenix 386 is also officially supported. FAS needs to be
	compiled with the command line flag `-DXENIX'. The makefile
	for SCO Xenix takes care of that. Thanks to Andreas
	Steinmetzler (andreas@oil.UUCP) for doing the port.

	If you have the RTSFLOW and CTSFLOW termio(7) flags,
	hardware handshake can be controlled by them.
	Note that enabling handware flow control via the
	minor device number overrides these flags. If you
	like to use them you need to create tty device nodes
	with minor device numbers in which the bit for hardware
	handshake is set to 0. Look at the description in the
	README file for more details.
	Note also that if you choose to use RTSFLOW and CTSFLOW
	all your programs that do initial access to tty devices
	(getty, uucico, cu, SLIP dialup program etc.) need to know
	about these flags or hardware handshake will not be used.

	The `O_EXCL' flag for the open(2) call is honored now.
	This allowes exclusive access to an FAS device without
	suffering from race conditions which could occure with
	the termio(7) XCLUDE flag method.

	The `fas_test_device' function returns a digit now that
	indicates at which phase the test exited due to an error.
	This error digit is displayed in the boot message. Thanks
	to Brian Beattie (beattie@visenix.UUCP) for sending me
	the necessary patches.

Bug Fixes:

	Automatic input FIFO flush after unblocking the getty
	open by the carrier or the unblock signal. This makes sure
	that there is no chance that there are characters in the
	FIFO that were received before the open got unblocked.

	The sdevice entry for the AST 4-port card had a wrong
	I/O address range (`s_fas-mux4'). This didn't affect FAS
	but is checked by the kernel config program.

	The gcc (GNU cc) support was removed because gcc's object
	file wants to link in some "helpful" functions that aren't
	contained in the kernel. But anyway, FAS is tuned so carefully
	and depends on the optimization behaviour of the AT&T
	standard C compiler that gcc won't have any advantages.

	I changed the method with which the `fas_test_device' function
	waits for certain events. The `delay' function was used
	for that purpose but it turned out that with some flavors
	of UNIX it is prohibited to use this function during the
	xxinit phase of the boot process. Now a simple timeout loop
	is used instead.

	Removed the ADAPT_TIME mechanismn introduced in release 2.05.

	The open() call now returns an `EBUSY' error number if the
	device is already open and can't be opened in the desired
	mode at this time.

	The handling of the RING signal needed fixing. Unlike the other
	three modem status lines RING generates an interrupt only at
	the trailing edge.

	No SIGHUP signal is sent any more if an ioctl call clears
	the CLOCAL termio(7) flag while there is no carrier present.
	SIGHUP is only sent if the actual DCD modem line drops.

	The files *-mux4 were renamed to *-ast4 because this type of
	card was originally developed by AST (AST 4-port card).

------------------------------------------------------------
	
release 2.08 Sun Feb 03, 1991

New Features:

	Bell Tech/Intel UNIX 3.2 is supported.

	SCO Xenix 286 is also supported now. Thanks to Nickolay Saukh
	(nms@saukh.rd.jvd.su) for providing the patches.

	The Bell Tech HUB-6 card can be used with FAS. Thanks to
	Keith Walker (kew@cims2.UUCP) for the patches.

	For AT&T derived flavors of UNIX there is a line automatically
	added to the kernel description file that makes the adding
	and removing of FAS possible via the `kconfig' program. Thanks
	to John Adams (johna@grumpy.boston.ma.us) for this idea.

	There is a mechanismn now that prevents excessive modem status
	interrupts caused by crosstalking between wires or by a loose
	cable.

	You can disable the FIFOs in a UART by "oring" the macro
	`NO_FIFO' to the base port address of this device. This is
	useful for mouse devices where you need immediate response
	to the mouse movement.

	The meaning of the bit mapped part of the minor device
	numbers has changed. Some rather useless functions were
	removed in favor of more control over the hardware handshake
	modes. Even systems where the SCO RTSFLOW/CTSFLOW termio(7)
	flags are not available can now use half duplex hardware
	flow control (selected via the minor device number).

	The assignment of RS232C lines to certain FAS functions
	is even more flexible now. This allows to connect two
	UNIX systems (with FAS) via a null modem cable, running
	a getty at both ends. For more details, read the paragraph
	about CABLING in the README file.

	A special handling of the NS16550A input FIFO was introduced.
	This causes multiple receiver interrupts (on the same IRQ
	line) to be synchronized so that only one interrupt is
	necessary to process all receiving ports. This reduces the
	interrupt handling overhead and therefore results in lower
	CPU load for concurrent serial input at high speeds.

	The `fas_event' function processes all scheduled events
	for all units with one single call. Previously, every unit
	launched its own timeout() call if there was work to
	do. This could lead to up to 16 timeouts at the same time,
	resulting in some timeout handling overhead. This overhead
	is minimized now.

Bug Fixes:

	There were two bugs that could cause a port to lock up,
	resulting in an immortal process.

	Almost any kernel sleep is killable now (at least with one or
	two `kill -9'). Therefore, there should be no more immortal
	processes. Even killing a process that is hanging in a
	close-on-exit call is possible.

	The meaning of the RTSFLOW/CTSFLOW termio(7) flags was converted
	to what SCO had in mind (half duplex flow control). This is for
	compatibility reasons. Full duplex RTS/CTS hardware flow control
	is still possible via the minor device number method. Thanks to
	Dmitry V. Volodin (dvv@hq.demos.su) for providing me with the
	necessary knowledge.

	If a process is already sleeping in a getty open it will only
	unblock on DCD low->high. In particular, if in the meantime
	the device was open for dialout and DCD is still present if
	the getty open takes over again this won't unblock the getty
	open any more.

	And there were, as usual, a number of other small bug fixes.

------------------------------------------------------------
	
release 2.09 Sun Jun 23, 1991

New Features:

	AT&T UNIX 3.2 Version 2.1 is supported.

	Support was added for SysVr4 UNIX 386 (with the tty compatibility
	drivers). This was mostly a problem of ANSI-fying certain parts
	of the FAS sources. For this operating system, there is no VP/ix
	support in FAS. This will change when FAS is converted into a
	STREAMS driver.

	Killing a process hanging on an FAS port that had output
	flow stopped was usually done by issuing one or two `kill -9'
	commands. However, this method could hang the whole UNIX kernel.
	Therefore, another method to release hung processes is
	introduced in this release.
	If you open an FAS device with the O_TRUNC flag, the input
	and output buffers of that device get flushed. As a side
	effect, if you had previously tried to kill a hung process,
	and it continued to hang on an FAS device, you simply have
	to open that device with the O_TRUNC flag, and the hung
	process is released. All you have to do is to type
	echo '\c' > /dev/ttyname
	and the device buffers are flushed.

	There is a new array called fas_overrun[], which is of
	type `uint', that contains three receiver overrun counters
	for NS16450, i82510 and NS16550A UART chips, in that order.
	If you have a tool that permits you to look at kernel
	variables during runtime, you can determine yourself
	whether the problems you may have might be caused by
	lost input characters. With every receiver overrun, the
	respective counter is incremented by one.

Bug Fixes:

	The problem with the excessive modem status interrupts
	is fixed. Well, kind of. It is suppressed, at least.
	Crosstalk between the lines in a serial cable wastes
	only a minor amount of CPU time now. Therefore, it isn't
	necessary any more to shut down a port when this happens.
	However, if you use an operating mode (selected by the
	minor device number) that assigns certain functions to
	the input pins at the RS232C connector (DCD, DSR, CTS and
	RI), and these pins toggle because of crosstalk in the cable,
	problems may still occure. But at least it won't panic the
	kernel any more, nor will it consume lots of CPU time.

	Additionally, in operating modes where FAS doesn't need to
	know anything about modem status lines, the modem status
	interrupt is actually disabled. For instance, when a minor
	device number of 0 + port# is used. On the other hand,
	switching the device to DOS mode always _enables_ the
	modem status interrupts.

	A problem was fixed when a port was in the canonical (cooked)
	mode and FAS still tried to protect the CLIST input buffer
	from overflowing. This blocked the connected terminal until
	a break signal or a hangup. The input buffer protection
	should, of course, only happen in raw mode.

	The TIMEOUT tty state flag isn't used any more by FAS.
	Because this flag is used by the line discipline as well,
	its usage in FAS could cause problems.

	There was a bug in the handling of one pointer in the
	fas_test_device() function.

	In fas_event(), looping for the same port several times until
	all events are serviced could cause temporary deadlocks. We
	now don't loop any more. If an event occures while in fas_event(),
	but the branch responsible for processing was already passed,
	this event has to wait until the next call of fas_event()
	(usually one or two kernel ticks later).

	The AIOCINFO ioctl() command returned the minor device number.
	Now it returns the unit number.

	SIGHUP will be sent only if the port is the controlling terminal
	of a process group.

	There was a problem with the initialization macros for the
	fas_modem[] and fas_flow[] arrays. Under Xenix 286, some
	of these macros expanded to a value of zero because the
	size of type int is 16 bits, while it is 32 bits for all
	the 386 UNIX flavors. This resulted in dropped bits with
	some macros that use the `<<' operator.

	An fasopen() call is checked immediately for permissions now,
	even if another process is currently hanging in fasclose().
	The fasopen() call, of course, can be completed only after
	the other process has returned from fasclose().

------------------------------------------------------------
	
release 2.09 PL1 Sun Sep 22, 1991

New Features:

	There is a new variable called fas_msi_noise. This
	is a counter that is incremented each time the modem
	status interrupt of a UART had to be disabled due to
	excessive logic level transitions on one or more
	modem status lines (DCD, DSR, CTS and RING).
	This can be used to check whether there is any
	crosstalking at high speeds in your serial cables
	and should be taken as a hint that you should improve
	your cables (shorter and/or shielded ones). Note
	that there are also some modems or other devices
	that cause this counter to be incremented (slowly,
	though). In this case fixing the cabling won't
	help.

	FAS now supports a port speed of 57600 bps. By
	default, in the array fas_port[] (`space.c') you can
	set a flag (`HIGH_SPEED') independently for each port
	to have 57600 bps instead of 38400 bps on the respective
	port. Due to interrupt latency in the UNIX kernel you
	will need a 486 mainboard even with NS16550A chips if
	you don't want to risk losing incoming characters. For
	terminals connected at this speed, a slower mainboard
	will suffice, however. To make this speed work well,
	the transmitter buffer size has been increased to 5000
	bytes.

	Another flag (`NO_TEST') can be set in fas_port[]
	(`space.c') to disable the testing procedure for
	the respective port. This can be used to allow
	UART chips (i.e. internal modems) that don't pass
	the test but seem to work anyway. Note that if you
	do that you're completely on your own if you have
	problems with FAS. I won't support you if you use
	this flag because using UARTs that need this flag
	means calling for trouble. I simply can't diagnose
	this kind of hardware problem from the remote.

	The SVR4 `CTSXON' and `RTSXOFF' hardware flow
	control flags are supported, although I still
	believe that FAS' minor device number based
	method for controlling hardware handshake modes
	is superiour to any method that is using ioctl()
	calls for that purpose.

	Made the UART testing in fas_test_device() even
	harder. Now it should detect brain dead chips
	more reliable.

Bug Fixes:

	Modified fasopen() to handle mixed (with and w/o
	O_NDELAY flag) invocations while there is no
	carrier.

	On dialout devices with modem control it was
	intended that after carrier drop the first
	TCSETA* ioctl() command would switch FAS to
	ignore DCD for that port again (as is the
	case after the initial fasopen() call). This
	breaks certain shells that do a TCSETA*
	command before they read from stdin, and therefore
	never notice that DCD dropped. They don't get
	the SIGHUP either because they are in another
	process group at this time (job control !).
	Now it is only possible to reset FAS in
	the above manner if the CLOCAL flag is set
	with the TCSETA* command. Once FAS is
	switched to ignore DCD, CLOCAL can be cleared
	again.

	If the carrier drops and modem control is
	enabled (CLOCAL is off), SIGCONT is sent
	before SIGHUP (only where available) to
	wake up stopped processes so that they will
	notice the hangup signal.

	Several other bug fixes, cleanups and improvements.

------------------------------------------------------------
	
release 2.10 PL0 Mon Aug 17, 1992

New Features:

	There are no interrupt vectors to be entered in `space.c'.
	The only place where int vectors are contained in this
	release is the `s_fas' file. The reason for this is that
	the interrupt function in FAS now scans all _active_ ports
	no matter what int vector they are assigned to. This is
	necessary in order to sort the ports by their speed. Scanning
	the fastest port(s) first makes receiver character loss less
	likely, especially at speeds > 19200 bps. Although this method
	has a slight CPU time overhead for only one running port the
	real advantage is that when more than one port is running,
	and especially when these ports are receiving NS16550A UARTs
	where the interrupt frequency optimization is used, the
	CPU time requirements for each additional running port are
	substantially lower than with previous FAS releases.

	Where available, the Makefile puts the kernel defines from
	`/etc/conf/cf.d/defines' into the compiler command line.

	There are now different Makefiles for ISC UNIX 2.x and 3.x.
	This has to do with a change in the ISC kernel config kit.

	Under SVR4 the copy of `fas.h' that goes to `/usr/include/sys'
	now gets the time stamp of the copy operation so that the
	dependency in the Makefile works.

	Either 57600 or 115200 bps can be used instead of 38400 bps.
	For 115200 a very fast mother board and a UNIX with a low
	interrupt latency is necessary to prevent input character loss.

	There is a flag `LOW_INT_LAT' that can be defined in the
	makefile if the UNIX kernel has a low tty interrupt latency.
	This saves a lot of CPU time at high speeds because the
	receiver FIFO trigger level is set to 8 instead of 4 (default),
	and therefore the receiver interrupt frequency is cut in half.

	The flags that can be "ored" into the base port address of
	a UART to change its default behaviour are now documented
	in the README file.

	Template files for the DigiChannel PC/8 card were added.

	Support for gcc has been added. If NO_ASM is _not_ defined
	inline code for the inb() and outb() functions is generated
	with the help of the __asm__ feature. However, when __asm__
	is used together with the `volatile' storage class gcc
	produces rather poor code. I assume that in this case gcc
	can't do some optimizations because they would break the
	inline assembler code. And the code gets even worse if
	-fstrength-reduce is used (with or without inline assembler
	code). Apparently gcc is over-optimizing the code so that
	it is in fact slower than without -fstrength-reduce. So
	don't use this flag. All tests where done with gcc 1.40.

	There is an interrupt acknowledge sequence in `space.c' now
	that is similar to the init sequence but is executed by the
	fasintr() function after all pending interrupts on all serial
	cards have been processed. This is a replacement for the
	fas_int_ack_port and fas_int_ack arrays that are gone because
	we don't use interrupt vectors any more inside FAS.

	The receiver and modem status interrupts are disabled now
	whenever they aren't needed. If they are disabled this
	saves some CPU time in the interrupt function.

	A new termio(7) flag CRTSFL under SCO UNIX 3.2.4 enables full
	duplex hardware flow control, but only if neither CTSFLOW nor
	RTSFLOW are set. See the termio(7) man page. However, remember
	that when you use a minor device number controlled hardware
	handshake mode (the prefered method with FAS, even under SCO
	UNIX and Xenix) the flags CTSFLOW, RTSFLOW and CRTSFL are
	ignored!

	For each port, it can be selected whether the SCO UNIX/Xenix
	CTSFLOW/RTSFLOW termio(7) flags enable half duplex hardware
	flow control (default, compatible with the sio driver), or if
	they enable full duplex hardware flow control (compatible with
	many "intelligent" serial cards from third party vendors).

	The RTS_TOG ioctl() command is supported (if available).

	The sources for this release, and also the object file, are
	somewhat bigger than the previous release. Besides other
	things this is caused by the inlining of some functions.
	These functions were called rather frequently and were
	small enough for inlining. This saves some function call
	overhead.

	There are lots of changes that yield a better use of
	register variables, especially in loops.

Bug Fixes:

	The method to flush the output buffers of a port while a
	process is hanging in fasclose() has been changed. In
	FAS 2.09 the buffers were flushed when the port was opened
	with the O_TRUNC flag. This caused some problems with shell
	scripts that wanted to write text with

		echo 'foo bar' > /dev/tty

	I changed FAS to use O_APPEND instead. So in order to flush
	the output buffers in this release one has to use

		echo '\c' >> /dev/ttyF00

	if the port `ttyF00' is hanging.

	The kernel `ttyhog' variable is used instead of the default
	TTYHOG value from `tty.h'. So FAS notices if this variable is
	tuned by the SysAdmin.

	The array `fas_info' has been renamed to `fas_internals'
	to prevent a name space collision under SVR4.

	`fas_overrun' and `fas_msi_noise' where declared `static'.
	Under some UNIX flavors a static kernel variable isn't
	found by programs that are used to look at variables in
	the running kernel. This is fixed now.

	The method how to handle concurrent fasopen() calls with
	and without O_NDELAY on a device that waits for a carrier
	has been changed back to what FAS 2.09.0 did. If there
	already is a process waiting for carrier and another process
	opens the device with O_NDELAY the waiting process is waked
	up and completes its fasopen() call regardless of the state
	of the carrier. This is because due to the AT&T kernel design
	we can't have both a sleeping and a working process on the
	same device. Patch #1 for FAS 2.09 introduced a bug which
	caused hung gettys. This error is fixed by going back to
	the method used in FAS 2.09.0.

	The problem that caused occasional crashes under SCO UNIX
	appears to be fixed. I don't know for sure why this is so.
	We'll see.

	When a process is waiting inside fasclose() for the
	output buffers to drain and the process receives a
	signal that is not ignored the output buffer is
	automatically flushed in order to allow fasclose()
	to complete before the signal handler is entered.
	This has to happen because the open file counter is
	decremented even if fasclose() was interrupted. I fact,
	fasclose() is expected to complete properly under all
	circumstances because the routines calling fasclose() don't
	check for signals or errors when fasclose() returns. So after
	the signal handler has done its work fasclose() wouldn't
	be entered again because the open file counter is already
	zero at this time. That means that whatever happens fasclose()
	must have done its cleanup for the port before it returns.

	Under SVR4 longjmp() wants a pointer as its parameter.

	The half and full duplex hardware handshake has been
	redesigned to be more bullet proof when it comes to
	switching from one mode to the other.

	The Logitech mouse problem has been solved. There is
	a bug in the generic ttiocom() support function that
	FAS needs to circumvent with some additional code.

	The incrementation of the counters in the sysinfo
	structure is fixed in that it happens only once for
	each interrupt and not once for every port that has
	work to do. This better reflects the actual interrupt
	load.

	Because a carrier drop is processed asynchronously in
	fas_event() it is necessary to at least stop the
	character output as soon as the modem status interrupt
	is detected. Now only up to 16 characters (one FIFO
	load with NS16550A) will be transmitted after carrier
	drop. This is in line with the latency of the hardware
	output handshake.

	And of course lots of other optimizations and small
	fixes.

------------------------------------------------------------
	
release 2.11 PL0 Mon Oct 11, 1993

Improvements:

	Better description of some of the user selectable symbolic
	constants in `fas.h' that allow OS dependent conditional
	compilation of the sources (file `INSTALLATION').

	Some cleanup of the README and the INSTALLATION file.

	Most of the text that was previously in the README file was
	converted to [NT]ROFF source format and transfered to the new
	fas(7) man page.

	There is a file `COPYING' now that contains the FAS copyright.

	Config files for the USENET II serial card have been added.

	All config files for multiport cards have COM1 and COM2
	additionally enabled because it is easier for the user to
	disable COM1 and/or COM2 (if they are not needed) than it
	is to add the necessary entries to the config files.

	The config files for the DigiChannel PC/8 card have been
	renamed to `*-gen8c12'. `gen' stands for generic and means
	that these config files can be used for 8-port cards from
	different vendors.

	The new file `m_fas' contains a sample entry for the
	/etc/conf/cf.d/mdevice file.

	The ORTSFL hardware flow control flag introduced in SCO UNIX
	3.2.4.2 is supported.

	Official GCC support (although not recommended).

	VP/ix support is enabled by default.

	If the file /etc/conf/init.d/fas already exists `make install'
	doesn't copy `i_fas' over it so that customized inittab lines in
	/etc/conf/init.d/fas are preserved.

	There is an explicit support address: fas@geminix.in-berlin.de
	Note, however, that this doesn't mean that you can get
	professional full-time support if you mail to this address.
	As FAS is a spare time project I will answer mails only as
	time permits.

	The outb()/inb() inline assembler optimizations for AT&T
	derived OS flavors have been dropped. Instead, there is now
	an AWK script that optimizes the `fas.s' file after compilation.
	There are other optimizations performed by this script as well.
	The makefiles for the OS platforms where this optimization is
	applicable contain the necessary awk invocation.

	In the past, short integers were used wherever applicable
	because of the somewhat smaller opcode size. However, tests
	have shown that under i386/i486 word operations are signifi-
	cantly slower than byte or double word operations. So the use
	of short integers is avoided now if possible. This has no
	effect on i286 which has word size as its native operand size.

	For modem controlled devices, after the first loss of carrier
	FAS ignores the carrier state and assumes it is missing until
	the last process closes the device. Additionally, in this state
	the modem enable output (usually DTR) is held low to prevent
	the modem from answering calls. This is a security feature in
	that it prevents new dialins if for some reason a process
	(shell etc.) hangs on this device. Otherwise, the next user
	calling in on this device would get the shell (or whatever
	process is hanging) of the user who started it, and therefore
	all his permissions. This actually happens from time to time
	and is a gaping security hole, especially if the previous user
	has root permissions. This protection feature can be disabled
	on a per port basis if it breaks any software.

	There is a new, more flexible mechanism for defining non-
	standard baud rates like 57600 and 115200 bps. Look at the
	fas(7) man page and `space.c' for more informations.

	Flags like `NO_TEST' that were previously "ored" into the
	base port address have their own array now (fas_modify [] in
	`space.c').

	There is a `NO_OVERRUN' flag for fas_modify []. It may be set
	for devices that have some sort of receiver overrun protection,
	for instance certain internal modems that use a 16x50 UART
	emulation and have their own receiver buffer.

	The FIFO modes and trigger levels for the NS16550A UART can be
	controlled on a per port basis (`space.c').

	The offset for the various UART registers from the base port
	address is variable and can be customized for unusual hardware
	designs (`space.c').

	For SCO UNIX and Xenix users, there is the new fas_vec[] array
	in `space.c'. If the interrupt vector numbers of the various
	ports are entered into this array, they are displayed by the
	FAS boot message. Users of other UNIX flavors can ignore this
	array.

	Copying between user and kernel data space is done by copyin()
	and copyout() because fubyte() and subyte() are marked obsolete
	in the AT&T driver reference manual.

	Made better use of register variables. We can have more than
	the usual three register variables in a function if we define
	those that aren't used in the entire function inside a block
	of statements. So a CPU register can be shared by several
	variables.

	Converted several small functions to inline code for faster
	execution.

	Merged fas_proc() and fas_cmd() to fasproc().

	The fasintr() function has been optimized so that it has to
	poll less UARTs to make sure that there are no more pending
	interrupts.

	The fas_rproc() function feeds the incoming characters
	directly into the receiver ring buffer instead of storing
	them in a temporary buffer first. So it's faster now.

	A new timeout mechanism in fas_rxfer() optimizes the character
	transfer from the receiver ring buffer to the CLIST buffers
	in order to reduce processing overhead in the CLIST routines.

	Character transfers between ring buffers and CLIST buffers
	in fas_rxfer() and fas_xxfer() are done by copying two or four
	characters at a time (using word (i286) or double word (i386+)
	accesses) whenever possible. Additionally, for AT&T derived
	UNIX flavors this copy operation is implemented as inline
	assembler code.

	The function declarations at the beginning of `fas.c' expand
	to ANSI C prototypes if an ANSI C compiler is used.

	OS dependent defines have been moved to `fas.h' and are
	automatically updated by the makefile.

	The ring buffer size has been increased to 10000 characters in
	order to cope with 115200 bps (not for Xenix 286).

	The `inittab' getty lines have a `-t 60' by default to time
	out after 60 seconds. This prevents getty from waiting
	indefinitely on a dialup modem line.

Bug Fixes:

	The TTYHOG problem on some platforms is fixed. Some UNIX flavors
	have a tunable `ttyhog' kernel variable, some don't. The
	`TUNABLE_TTYHOG' symbolic constant in `fas.h' can be used
	to tell FAS whether your system has this kernel variable or
	not.

	FAS initializes all variables and arrays and doesn't rely on
	global memory being initialized to zero. To my astonishment
	I read that global memory in the kernel isn't guaranteed to
	be initialized to zero. I don't know if this is true for all
	platforms. So I don't take chances and let FAS do its own
	initialization.

	Device driver functions like fasopen(), fasclose() etc. are
	defined as having a result type of `int'. That is, they don't
	really return a result, but a function defined without an
	explicit result type automatically has a result type of `int'.
	The respective FAS functions return no result, but to make
	ANSI C compilers happy they have to be defined with a result
	type of `void' instead of `int' to make it obvious that they
	don't have a return value. This dilema results from the kernel
	originally being compiled with a K&R C compiler (not ANSI C)
	where one gets away with `int' functions returning no result
	values.

	Fixed a bug that would prevent the dialin process (getty)
	from reopening the device after a dialout process using this
	device was interrupted while waiting inside of fasopen() for
	the device lock.

	The `RTS_TOG' ioctl() command suspends/resumes the character
	output. This is more compatible with the implementations in
	the vendor drivers.

	ttiocom() is called at SPLWRK so that the fas_event() function
	can't be invoked before fas_param() has been called after
	ttiocom(). This makes sure that there are no discrepancies
	between the tty structure (set by ttiocom()) and the
	fas_internals structure (set by fas_param()) when line
	discipline functions are called from fas_event().

	SCO UNIX uses the same SPL assignment as SCO Xenix (SPL5 and
	SPL7). Previously, FAS under SCO UNIX used the original AT&T
	assignment (SPL6 and SPLTTY). This incompatibility should be
	the reason for all the problems that only occured under SCO
	UNIX (crashes, hung ports etc.). Thanks to Mark Lyda
	(mark@startech.com) for pointing this out.

	There is an incompatibility between SCO UNIX/Xenix and the
	rest of the world in that SCO UNIX/Xenix passes a pointer
	to `struct termss' with the `AIOCSETSS' ioctl() command while
	on the other platforms a copy of this structure is passed
	as the argument itself. Thanks to Robert Lipe
	(robertl@amsg.arnet.com) for this information.

	fas_test_device() uses the highest possible baud rate on
	the respective port (derived from the assigned fas_baud[] table
	in `space.c') for the test run. In previous releases the highest
	overall baud rate was used on all ports, even if a port would
	never actually run at this speed.

	The MCR/MSR test routine in fas_test_device() copes with slow
	MCR/MSR registers as it isn't really necessary for FAS'
	operation that these registers are particularly fast. It's
	only necessary that all eight modem status bits change state
	at the same time (clocked operation).

	Fixed a bug that could stall the receiver CLIST queue under VP/ix.

	Switching from an operating mode that has modem status interrupts
	disabled to a mode that enables modem status interrupts caused
	a DTR drop if the DCD status was low before the modem status
	interrupts were disabled.

	If the O_NDELAY flag is set when fasclose() is called (last close),
	FAS doesn't wait until the output buffers have drained. Instead,
	it flushes the output buffers so that it can complete fasclose()
	without delay.

	File `fas.h' is unconditionally copied to the system include
	directory when `make install' is executed (except for SCO Xenix).
	So it is installed at the same time as `space.c', which happens
	to be the only file outside of the FAS source directory that uses
	`fas.h'. This change makes the installation of `fas.h' more bullet
	proof in cases where there is already another version of FAS
	installed.

	When a dialout process opens a logical dialout device while a
	dialin process waits for the carrier on the corresponding logical
	dialin device, the physical device is now closed internally before
	reopening it for the dialout process.

	fas_close_device() doesn't disable the FIFO mode in the UART
	anymore as this is unnecessary.

	The termio(7) XCLUDE flag was tested against the wrong variable.
	Under SCO UNIX this had the effect that when CRTSFL/ORTSFL was
	set, successive opens failed with EBUSY for users != root.

	The gcc inline assembler instructions `inb' and `outb' have been
	changed from the Intel to the AT&T syntax for SCO UNIX. This is
	because gcc uses the AT&T assembler by default.

	Gcc's automatic register allocation does a poor job on the FAS
	sources. Therefore, we force gcc to use registers for certain
	variables.

------------------------------------------------------------
	
release 2.12 PL0 Wed Jan 12, 1994

Improvements:

	In previous releases RTS was dropped immediately when the device
	was closed while DTR was cleared 500 ms later. Also, when the
	device was closed and the HUPCL flag was _not_ set, DTR was left
	untouched but RTS was dropped. This can cause problems with pointer
	devices like mice that get their power supply from the DTR and RTS
	lines of the serial port. Therefore, RTS is dropped now together
	with DTR after the 500 ms delay or is also left untouched if HUPCL
	was not set.

	The fasinit() function checks now whether a port can trigger an
	interrupt, that is, whether the interrupt (IRQ) lines in both your
	hardware and the config files are set up properly. The exceptions
	from this are SCO UNIX and Xenix because these OS flavors don't
	allow interrupts during the init phase.

	The fas_vec[] array in `space.c' is compiled in only under SCO UNIX
	and Xenix as other UNIX flavors don't use it.

	In previous FAS versions, the transmitter and receiver ring buffers
	were part of the `fas_internals' structure and were therefore
	allocated statically at compile time. With increasing buffer sizes
	(because of increasing baud rates) FAS eventually became a real memory
	hog. Beginning with this release, however, FAS allocates the ring
	buffer memory dynamically and for each port independently, its size
	depending on the highest baud rate the respective port can run at.
	Memory is allocated with the first open of the port device and is
	freed when the last process closes the device. Therefore, unused ports
	consume almost no memory. Note, however, that a port having a getty on
	it qualifies as open and therefore has already allocated the ring
	buffer memory. Note also that under SCO Xenix 286 the memory is still
	allocated statically at compile time. This is because the i286 memory
	model with its segmentation would make it too complicated to implement
	dynamic memory allocation under this OS.

	GCC versions older than 2.4.5 tend to break FAS, so don't use them.
	The file `INSTALLATION' has been updated accordingly.

	The fas(7) man page has been updated.
