
Stallion Multiport Serial Driver Readme
---------------------------------------

Version: 0.2.0 beta
Date:    19JUL95
Author:  Greg Ungerer (gerg@stallion.oz.au)



1. INTRODUCTION

This is a Linux driver for some of the Stallion Technologies range of
multiport serial boards. There is really 2 drivers in this package. One is
for the Stallion smart boards, the other for the true Stallion intelligent
multiport boards.

These drivers have not been developed by Stallion Technologies. I developed
them in my spare time in the hope that they would be useful. As such there is
no warranty or support of any form (see the GNU general public license included
for more detail).

What this means is that these drivers are not officially supported by Stallion
Technologies, so don't ring their support if you can't get it working. They
will probably not be able to help you. Instead email me if you have problems
or bug reports and I will do what I can...

All host driver source is included in this package, and is copyrighted under
the GNU GPL. The board "firmware" code in this package is copyright Stallion
Technologies (the files cdk.sys and 2681.sys).


1.1 SMART MULTIPORT BOARD DRIVER

This driver has been used for some months now, so there is a good level of
confidence in its operation!  Therefore this version should be considered as
very good Beta quality.

This driver supports the EasyIO and EasyConnection 8/32 range of boards.
All of these boards are not classical intelligent multiport boards, but are
host based multiport boards that use high performance Cirrus Logic CL-CD1400
RISC UART's (they have built in FIFO's, automatic flow control, and some
other good stuff).

The EasyIO range of cards comes in 3 forms, the EasyIO-4, EasyIO-8 and the
EasyIO-8M. All of these are non-expandable, low cost, ISA, multiport boards
with 4, 8 and 8 RS-232C ports respectively. The EasyIO-8M is not currently
supported by this driver. Though it is pretty easy to support so I'll do
that when I get a chance. Each EasyIO board requires 8 bytes of IO address
space and 1 interrupt. On an EISA system it is possible to share 1 interrupt
between multiple boards. The EasyIO-4 has 10 pin RJ connectors, and the
EasyIO-8 comes with a dongle cable that can be either 10 pin RJ connectors or
DB-25 connectors. The EasyIO-8M has 6 pin RJ connectors.

The EasyConnection 8/32 family of boards is a relatively low cost modular
range of multiport serial boards. The EasyConnection 8/32 boards can be
configured to have from 8 to 32 serial ports by plugging in external serial
port modules that contain either 8 or 16 ports each. There is a wide range
of external modules available that offer: DB-25 connectors, RJ-45 connectors
(both with RS-232 D and E compatible drivers), and also RS-422 ports. The
EasyConnection 8/32 boards come in ISA and MCA bus versions. The board takes
the form of a host adapter card, with an external connector cable that plugs
into the external modules. The external modules just clip together to add
ports (BTW they are not hot pluggable). Each EasyConnection 8/32 board
requires 2 separate IO address ranges, one 2 bytes in size and a secondary
region of 32 bytes. Each board also requires 1 interrupt, on EISA systems
multiple boards can share 1 interrupt. The secondary IO range (the 32 byte
range) can be shared between multiple boards on any bus type.

So thats the hardware supported by the smart board driver (sounds like a
marketing spiel doesn't it!).


1.2 INTELLIGENT MULTIPORT BOARD DRIVER

The intelligent multiport serial driver is much newer than the smart board
driver, so it has not undergone quite as much field testing at this point.
It does however appear to be very stable, and should be considered Beta
quality. Any feedback on its operation would be greatly appreciated.

This driver is for Stallion's range of true intelligent multiport boards, it
supports the EasyConnection 8/64, ONboard, Brumby and original Stallion
familys of multiport boards. The EasyConnection 8/64 and ONboard boards come
in ISA, EISA and Microchannel bus versions. The Brumby and Stallion boards
are only available in ISA versions.

The EasyConnection 8/64 family of boards is a medium cost, high performance,
modular range of intelligent multiport serial boards. The EasyConnection 8/64
boards can be configured to have from 8 to 64 serial ports by plugging in
external serial port modules that contain either 8 or 16 ports each (these
modules are the same used by the EasyConnection 8/32 board). There is a wide
range of external modules available that offer: DB-25 connectors, RJ-45
connectors (both with RS-232 D and E compatible drivers), and also RS-422
ports. The board takes the form of a host adapter card, with an external
connector cable that plugs into the external modules. The external modules
just clip together to add ports (BTW they are not hot pluggable). Each
EasyConnection 8/64 board requires 4 bytes of IO address space and a region
of memory space. The size of the memory region required depends on the exact
board type, the EISA version requires 64 Kbytes of address space (that can
reside anywhere in the 4 Gigabyte physical address space), the ISA and MCA
boards require 4 Kbytes of address space (which must reside in the lower
1 Mbyte of physical address space - typically in the c8000 to e0000 range).
No interrupts are required. The physical memory region of multiple
EasyConnection 8/64 boards can be shared, but each board must have a separate
IO address space.

The ONboard family of boards are traditional intelligent multiport serial
boards. They are Stallion's older range of boards with a limited expansion
capability. They come in 4, 8, 12, 16 and 32 port versions. The board uses
the same base card (which has 4 ports on it) and is expanded to more ports
via a mezzanine board that attaches directly onto the board. External panels
plug into the ONboard providing RS-232C ports with DB-25 plugs. An RS-422
DB-25 dual interface panel is also available. The ISA and microchannel
ONboards requires 16 bytes of IO address space and 64K bytes of memory
space. The memory space can be anywhere in the 16 Mbyte ISA bus address
range. No interrupt is required. The EISA ONboard requires 64 Kbytes of
memory space, that can be anywhere in the 4 Gigabyte physical address space.
All ONboard boards can share their memory region with other ONboards (or
EasyConnection 8/64 boards).

The Brumby family of boards are traditional, low cost intelligent multiport
serial boards. They are non-expandable and come in 4, 8 and 16 port versions.
They are only available for the ISA bus. The serial ports are all on DB-25
"dongle" cables that attach to the rear of the board. Each Brumby board
requires 16 bytes of IO address space and 16 Kbytes of memory space. No
interrupts are required.

The original Stallion boards are old, they went out of production some years
back. They offer limited expandability and are available in 8 or 16 port
configurations. An external panel is used which houses 16 RS-232C ports with
DB-9 connectors. They require 16 bytes of IO address space, and either 64K
or 128K of memory space. No interrupt is required.

Thats the boards supported by the second driver. The ONboard, Brumby and
Stallion boards are Stallions older range of intelligent multiports - so
there is lots of them around. They only support a maximum baud rate of
38400. The EasyConnection 8/64 is about 18 months old and is a very high
performance multiport board. It has about 4 times the output performance
of an ONboard, and about 10 times the the input performance. They also
support up to 115200 baud.


1.3 HOW TO GET BOARDS

I get asked this question a _lot_. So I am including a section here on where
to get boards. Stallion Technologies has offices all over the world, as well
as many more distributors and resellers. To find out about local availability
please contact the nearest Stallion office and they can give you all the
information you need. Look in the "Offices" file in the driver distribution
for a current list of Stallion offices.

Another good source of information about the Stallion range of boards and
local availability is on the Stallion Web page. Check it out at
http://www.stallion.com .



2. INSTALLATION

This code was originally developed on a 1.1.52 kernel. Although I did some
early work on a 1.1.18 kernel as well. Most recently I have been using a
version 1.2.11 kernel. The drivers "as is" will only work on 1.2.5 kernels
and above. Sorry!

The drivers can now be used as loadable modules or compiled into the kernel.
So, depending on which form of driver loading you decide to use, the
installation procedure will be a little different.

You will need to edit the driver(s) to enter the boards that you want to use.
Its pretty easy, if you follow the instructions below. Both drivers can support
up to 4 boards. The smart card driver supports any combination of EasyIO and
EasyConnection 8/32 boards (up to a total of 4). The intelligent driver
supports any combination of ONboards, Brumbys, Stallions and EasyConnection
8/64 boards (up to a total of 4).


2.1 LOADABLE MODULE DRIVERS

You will need the gcc compiler and make installed to make the driver modules.

To build the driver modules:
    1. Setup the driver configuration for the boards. If using EasyIO or
       EasyConnection 8/32 boards, do:
       vi stallion.c
          - find the definition of the stl_brdconf array (of structures),
            it is near the top of the file
          - modify this to what boards you are going to install (the comments
            before this structure should help)
          - save and exit
       If using ONboard, Brumby, Stallion or EasyConnection 8/64 boards then do:
       vi istallion.c
          - find the definition of the stli_brdconf array (of structures),
            it is near the top of the file
          - modify this to what boards you are going to install (the comments
            before this structure should help)
          - save and exit
    2. make module
       This will compile the driver modules, as stallion and istallion.

Thats it!  Pretty easy isn't it!
The stallion module is the EasyIO and EasyConnection 8/32 driver, the
istallion module is the ONboard, Brumby, Stallion and EasyConnection 8/64
driver.

To load up the smart board driver use:
    insmod ./stallion
This will load the EasyIO and EasyConnection 8/32 driver. It will output a
message to say that it loaded and also print the driver version number. It
will also print out whether it found the configured boards or not. (These
messages may appear in your /var/adm/messages file depending on how the
klogd and syslogd daemons are setup on your system).

To load the intelligent board driver use:
    insmod ./istallion
It will output similar messages as the smart board driver.


2.2 STATIC DRIVERS (KERNEL LINKED)

You will need to build a new kernel to compile the drivers into. So the first
thing you need is to have the full kernel source. Most people will have this
(I hope!). The following assumes that the kernel source is in
/usr/src/linux.

You will need to edit the driver(s) to enter the boards that you want to use.
Its pretty easy, if you follow the instructions below. Both drivers can support
up to 4 boards. The smart card driver supports any combination of EasyIO and
EasyConnection 8/32 boards (up to 4!). The intelligent driver supports any
combination of ONboards, Brumbys, Stallions and EasyConnection 8/64 boards
(up to a total of 4).

To install the drivers:
    1. cp stallion.c istallion.c cd1400.h cdk.h /usr/src/linux/drivers/char
    2. cd /usr/src/linux/drivers/char
    3. vi tty_io.c
          - goto the end of the file
          - add a line between the following lines:
              kmem_start = pty_init(kmem_start);
              return kmem_start;
          - depending on what type of boards you plan on using add one of the
            following lines (or both even!).
            To use EasyIO or EasyConnection 8/32:
              kmem_start = stl_init(kmem_start);
            To use ONboard, Brumby, Stallion or EasyConnection 8/86:
              kmem_start = stli_init(kmem_start);
          - so the result should look something like:
              kmem_start = pty_init(kmem_start);
              kmem_start = stl_init(kmem_start);
              return kmem_start;
          - save and exit
    4. Setup the driver configuration for the boards. If using EasyIO or
       EasyConnection 8/32 boards, do:
       vi stallion.c
          - find the definition of the stl_brdconf array (of structures),
            it is near the top of the file
          - modify this to what boards you are going to install (the comments
            before this structure should help)
          - save and exit
       If using ONboard, Brumby, Stallion or EasyConnection 8/64 boards then do:
       vi istallion.c
          - find the definition of the stli_brdconf array (of structures),
            it is near the top of the file
          - modify this to what boards you are going to install (the comments
            before this structure should help)
          - save and exit
    5. vi Makefile
          - add "stallion.o istallion.o" into the lines that list OBJS
          - add "stallion.c istallion.c" into the lines that list SRCS
            these lines already list all the other .o and .c files in
            this driver area, so just add stallion entries to the ends
          - save and exit
    4. cd /usr/src/linux
    5. build a new kernel - if you haven't done this before you may want to
       read the README file in /usr/src/linux.

And there you have it, easy isn't it!  The fact that you have to edit the
tty_io.c file is a bit bodgy, I haven't figured out a better way to do
this yet (any ideas?).

So once you have a new kernel built, reboot to start it up. On startup the
driver will output a message to say it is operational (with the driver
version number). It will also print out if it could find the boards listed
in its configuration structure or not.


2.3 SHARING INTERRUPTS

As mentioned in the introduction it is possible to share interrupts between
multiple EasyIO and EasyConnection 8/32 boards in an EISA system. To do this
you will need to do a couple of things:

1. When entering the board resources into the stallion.c file you need to
   mark the boards as using level triggered interrupts. Do this by replacing
   the "0" entry at field position 6 (the last field) in the board
   configuration structure with a "1". (This is the structure that defines
   what board type, io locations, etc, that each board is using). All
   boards that are sharing an interrupt must be set this way, and each board
   should have the same interrupt number specified here as well.
   Now build the module or kernel as you would normally.

2. When physically installing the boards into the system then you must enter
   the system EISA configuration utility. You will need to install the EISA
   configuration files for *all* the EasyIO and EasyConnection 8/32 boards
   that are sharing interrupts. The Stallion EasyIO and EasyConnection 8/32
   EISA configuration files required are supplied by Stallion Technologies
   on the DOS Utilities floppy (usually supplied in the box with the board
   when purchased, if not you can pick it up from Stallion's FTP site at
   ftp.stallion.com). You will need to edit the board resources to choose
   level triggered interrupts, and make sure to set each boards interrupt
   to the same IRQ number.

Thats it!  You must complete both the above steps for this to work. Next
when you boot up or load the driver your EasyIO and EasyConnection 8/32
boards will be sharing interrupts.


2.4 USING HIGH SHARED MEMORY

The EasyConnection 8/64-EI, ONboard and Stallion boards are capable of
using shared memory addresses above the usual 640K - 1Mb range. The ONboard
ISA and the Stallion boards can be programmed to use memory addresses upto
16Mb (the ISA bus addressing limit), and the EasyConnection 8/64-EI and
ONboard/E can be programmed for memory addresses upto 4Gb (the EISA bus
addressing limit).

The istallion intelligent driver does offer support for these higher memory
addresses with a couple of limitations. By default support for these higher
memory addresses is not compiled into the driver. This is because it relys
on kernel functions that are not normally exported as part of the Linux
loadable module system.

So to use the high memory support you need to either staticly link the
driver into the kernel, or add the required symbols into the Linux kernel
symbol exporting code. Linking the driver into the kernel is described in
the basic installation section above. To add the appropriate symbols into
the kernel export code you need to:

1. cd /usr/src/linux/kernel
   (assuming you linux kernel code is in /usr/src/linux)
2. vi ksyms.c
   - find the line that reads
        X(vfree),
   - after this line insert the following line
        X(remap_page_range),
   - save and exit
3. cd ..
4. build a new kernel (usually just make)

This will export the "remap_page_range" function for loadable modules,
which is required for the higher memory support code.

Finally you need to enable the code in the istallion driver. To do this
edit the istallion.c file, and serach for the symbol STLI_HIMEMORY. It is
near the top of the file, and will be a line that reads

#define	STLI_HIMEMORY	0

Change the "0" to a "1". This enables the high memory support code in
the driver. You will then need to rebuild the module or rebuild the
kernel to incorporate the change. You off-course will also need to modify
the board resource configuration information to use a higher memory
address.

Once these changes are in place the driver will work as it did before.
Note that the physical memory address range is software programmed on the
EasyConnection 8/64-EI and ONboards, but must be set via DIP switches on
the original Stallion boards.


2.3 TROUBLE SHOOTING

If a board is not found by the driver but is actually in the system then the
most likely problem is that the IO address is wrong. Change it in the driver
stallion.c or istallion.c configuration structure. Then either rebuild the
kernel or modules, or change it on the board. On EasyIO and EasyConnection 8/32
boards the IRQ is software programmable, so if there is a conflict you may
need to change the IRQ used for a board in the stallion.c configuration
structure. No interrupts to worry about for ONboard, Brumby, Stallion or
EasyConnection 8/64 boards. The memory region on EasyConnection 8/64 and
ONboard boards is software programmable, but not on the Brumbys or Stallions.


2.4 INTELLIGENT DRIVER OPERATION

The intelligent boards also need to have their "firmware" code down-loaded
to them. This is done via a user level application supplied in the driver
package called "stlload". Compile this program where ever you dropped the
package files, by typing "make". In its simplest form you can then type
    ./stlload -i cdk.sys
in this directory and that will down load board 0 (assuming board 0 is an
EasyConnection 8/64 board). To download to an ONboard, Brumby or Stallion do:
    ./stlload -i 2681.sys

Normally you would want all boards to be down-loaded as part of the standard
system startup. To achieve this add one of the line above into the
/etc/rc.d/rc.S or /etc/rc.d/rc.serial file. To down load each board just add
the "-b <brd-number>" option to the line. You will need to download code for
each board. You should probably move the stlload program into a system
directory, such as /usr/sbin. Also the default location of the cdk.sys image
file in the stlload down-loader is /usr/lib/stallion. So create that directory
and put the cdk.sys and 2681.sys files in it. (Its a convenient place to put
them anyway). So as an example your /etc/rc.d/rc.S file might have the
following lines added to it (if you had 3 boards):
    /usr/sbin/stlload -b 0 -i /usr/lib/stallion/cdk.sys
    /usr/sbin/stlload -b 1 -i /usr/lib/stallion/2681.sys
    /usr/sbin/stlload -b 2 -i /usr/lib/stallion/2681.sys

The image files cdk.sys and 2681.sys are specific to the board types. So the
cdk.sys will only function correctly on an EasyConnection 8/64 board. Similarly
the 2681.sys image fill only operate on ONboard, Brumby and Stallion boards.
If you load the wrong image file into a board it will fail to start up, and
off-course the ports will not be operational!

If you are using the modularized version of the driver you might want to put
the insmod calls in the startup script as well (before the download lines
obviously).



3. USING THE DRIVERS

Once the driver is installed you will need to setup some device nodes to
access the serial ports. Use the supplied "mkdevnods" script to automatically
create all possible device entries required for all 4 boards. This will
create the normal serial port devices as /dev/ttyE# where # is the port number
starting from 0. A bank of 64 minor device numbers is allocated to each board.
So the first port on the second board is port 64, etc. A set of callout type
devices is also created, they are created as the devices /dev/cue# where # is
the same as for the ttyE devices.

For the most part the Stallion driver tries to emulate the standard PC system
com ports and the standard Linux serial driver. The idea is that you should
be able to use Stallion board ports and com ports inter-changeably without
modifying anything but the device name. Anything that doesn't work like that
should be considered a bug in this driver!

If you look at the driver code you will notice that it is fairly closely
based on the Linux serial driver (linux/drivers/char/serial.c). This is
intentional, obviously this is the easiest way to emulate its behavior!

Since this driver tries to emulate the standard serial ports as much as
possible then most system utilities should work as they do for the standard
com ports. Most importantly "stty" works as expected and "setserial" can be
used just like for the serial ports (excepting the ability to auto-configure
the IO and IRQ addresses of boards). Higher baud rates are supported in the
same fashion through setserial or using the CBAUDEX extensions. Note that
the EasyIO and EasyConnection (all types) support 57600 and 115200 baud, the
older boards including ONboard, Brumby and original Stallion support a
maximum baud rate of 38400.

This driver should work with anything that works on standard Linux serial
ports. Having said that, I have used it on at least the following types of
"things" under Linux:
    a) standard dumb terminals (using agetty, getty)
    b) serial mice (under X)
    c) modems (using cu, uucp, minicom, seyon, uugetty)
    d) slip and ppp connections

If you are unfamiliar with how to use serial ports, then get the Serial-HOWTO
by Greg Hankins. It will explain everything you need to know!



4. PERFORMANCE NUMBERS

Using a slightly modified version of the TBENCH 3.0 set of serial port
benchmarks running under Linux I collected the following loose set of numbers.
I haven't done any input benchmarking yet, will do that when I get a chance.
(The slight modification to the benchmark programs was to add support for
the higher baud rates, above 38400).

These numbers where collected on a 486/DX33 no-name clone with 8Mb of RAM.
Below is a summary (I have the full run, but there is no point including it
all here...)

With an EasyConnection 8/32 and 24 ports installed:

Raw output (-opost) numbers:
8  ports at 9600   baud, did 8  ports at average 982   chars/s used 6  % CPU
16 ports at 9600   baud, did 16 ports at average 982   chars/s used 12 % CPU
24 ports at 9600   baud, did 24 ports at average 980   chars/s used 18 % CPU
8  ports at 38400  baud, did 8  ports at average 3857  chars/s used 19 % CPU
16 ports at 38400  baud, did 16 ports at average 3861  chars/s used 36 % CPU
24 ports at 38400  baud, did 24 ports at average 3858  chars/s used 57 % CPU
8  ports at 115200 baud, did 8  ports at average 11153 chars/s used 49 % CPU
16 ports at 115200 baud, did 16 ports at average 11130 chars/s used 87 % CPU
24 ports at 115200 baud, did 24 ports at average 8892  chars/s used 95 % CPU

Cooked output (opost) numbers:
8  ports at 9600   baud, did 8  ports at average 965   chars/s used 10  % CPU
16 ports at 9600   baud, did 16 ports at average 965   chars/s used 20  % CPU
24 ports at 9600   baud, did 24 ports at average 965   chars/s used 30  % CPU
8  ports at 38400  baud, did 8  ports at average 3811  chars/s used 34  % CPU
16 ports at 38400  baud, did 16 ports at average 3817  chars/s used 66  % CPU
24 ports at 38400  baud, did 24 ports at average 3766  chars/s used 88  % CPU
8  ports at 115200 baud, did 8  ports at average 10652 chars/s used 86  % CPU
16 ports at 115200 baud, did 16 ports at average 6080  chars/s used 100 % CPU
24 ports at 115200 baud, did 24 ports at average 4027  chars/s used 100 % CPU

So there it is. I don't really have any numbers for any of the common dumb
cards, so its hard to compare against them. Faster CPU systems will have
lower CPU overhead, slower CPU systems will have a larger overhead.

I ran the same benchmarks above on the same system using an EasyConnection 8/64
board, and got the following results.

Raw output (-opost) numbers:
8  ports at 9600   baud, did 8  ports at average 966   chars/s used 4  % CPU
16 ports at 9600   baud, did 16 ports at average 957   chars/s used 6  % CPU
24 ports at 9600   baud, did 24 ports at average 960   chars/s used 8  % CPU
8  ports at 38400  baud, did 8  ports at average 3837  chars/s used 5  % CPU
16 ports at 38400  baud, did 16 ports at average 3858  chars/s used 9  % CPU
24 ports at 38400  baud, did 24 ports at average 3854  chars/s used 20 % CPU
8  ports at 115200 baud, did 8  ports at average 11580 chars/s used 11 % CPU
16 ports at 115200 baud, did 16 ports at average 11573 chars/s used 20 % CPU
24 ports at 115200 baud, did 24 ports at average 10667 chars/s used 27 % CPU

Cooked output (opost) numbers:
8  ports at 9600   baud, did 8  ports at average 948   chars/s used 7  % CPU
16 ports at 9600   baud, did 16 ports at average 951   chars/s used 14 % CPU
8  ports at 38400  baud, did 8  ports at average 3856  chars/s used 22 % CPU
16 ports at 38400  baud, did 16 ports at average 3863  chars/s used 44 % CPU
8  ports at 115200 baud, did 8  ports at average 11597 chars/s used 63 % CPU
16 ports at 115200 baud, did 16 ports at average 8455  chars/s used 91 % CPU



5. NOTES

The smart board driver (EasyIO and EasyConnection 8/32) has only a few minor
changes since the previous release. Mostly minor bug fixes, it seems to be
very stable at the moment, there is no known out-standing bugs at this
point... 

The intelligent board driver (EasyConnection 8/64, ONboard, Brumby and
Stallion) has had a few bugs fixed. I have also reworked the character
cooking routines to greatly improve their performance. Also added the code
to support the higher memory addresses. So there is a few changes in there.

The device naming scheme has been changed. It is now conformant with the
Linux Device Registry. The major numbers for the devices have also changed,
and are now registered. If you want to use the old name scheme for
compatability reasons then use the "mkdevnods.old" script - it creates old
style device names (it uses the new major numbers though).

You can use both drivers at once if you have a mix of board types installed
in a system. However to do this you will need to change the major numbers
used by one of the drivers. Currently both drivers use major numbers 24 and
25 for their port devices. Change one driver to use some other major numbers,
and then modify the mkdevnods script to make device nodes based on those new
major numbers. For example you could change the stallion.c driver to use
major numbers 30 and 31 (don't use 28, its used by istallion.c driver for its
sio memory device!). You will also need to create device nodes with different
names for the ports...

Finding a free physical memory address range can be a problem. The older
boards, like the Stallion and ONboard need large areas (64K or even 128K), so
they can be very difficult to get into a system. If you have 16 Mb of RAM
then you have no choice but to put them somewhere in the 640K -> 1Mb range.
ONboards required 64K, so typically 0xd0000 is good, or 0xe0000 on some
systems. If you have an original Stallion board, "V4.0" or Rev.O,
then you need a 64K memory address space, so again 0xd0000 and 0xe0000 are
good. Older Stallion boards are a much bigger problem, they need 128K of
address space and must be on a 128K boundary. If you don't have a VGA card
then 0xc0000 might be usable - there is really no other place you can put
them below 1Mb.

Both The ONboard and old Stallion boards can use higher memory address as
well, but you must have less than 16Mb of RAM to be able to use them. Usual
high memory addresses used include 0xec0000 and 0xf00000.

The Brumby boards only require 16Kb of address space, so you can usually
squeeze them in some where. Common addresses are 0xc8000, 0xcc000, or in
the 0xd0000 range. EasyConnection 8/64 boards are even better, they only
require 4Kb of address space, again usually 0xc8000, 0xcc000 or 0xd0000
are good.

If you are using an EasyConnection 8/64-EI or ONboard/E then usually the
0xd0000 or 0xe0000 ranges are the best options below 1Mb. If neither of
them can be used then the high memory support to use the really high address
ranges is the best option. Typically the 2Gb range is convenient for them,
and gets them well out of the way.



6. ACKNOWLEDGEMENTS

This driver is loosely based on code written by Theodore T'so and Linus
Torvalds, and others, so a big thanks to them all!  Also a thanks to
Stallion Technologies for use of their equipment. Lets hope that much
more development gets done on this way cool OS! 



7. DISCLAIMER

I do not speak for Stallion Technologies in any capacity, officially or
un-officially.

