Software Installation Instructions for DPT4, DPT5 and DPT6
The software package includes device drivers, APIs, and support and
diagnostic programs for Communication Automation Corporation's (CAC)
desktop PCI, DPT boards. This family of boards consists of the DPT4,
DPT5 PCI boards and the DPT6 PCIe board. The device driver, API and
utility programs support all three of these boards and references to
"DPT4 software" generally refers to the software package and not a
particular board model.
The software distributions for Solaris, Linux and Windows are available
for downloading from the CAC Software Site
<http://www.cacdsp.com/sub/software.html> or on CDROM.
This document describes how to install the DPT software package on
A. Solaris and Linux Systems
B. Windows Systems (version 2000 - 2008)
DPT Software Installation for Solaris and Linux
The DPT Software supports Solaris 2.6 through Solaris 10 on
Intel/AMD (x86) and Sparc 32-bit and 64-bit platforms. Linux
kernels 2.4 and 2.6 are supported on Intel x86 and ia64 platforms
(SGI Altix is the only ia64 system tested).
An installation tool from the GNU Project (www.gnu.org
<http://www.gnu.org/>) is used to configure the software for a
particular target environment. The file named INSTALL in the
top-level directory of the installation contains generic
information about using the configuration tool.
Note that while you may be able to unpack and install the
libraries and programs as a normal Unix user, you will need to
have root access privileges to install the device driver.
Specific, step-by-step instructions are provided below in the
following sections:
1. Install the DPT Boards
2. Download and Extract the Software Distribution
3. Configure the Software
3a. Choose the Installation Directory
3b. Choose the Build Directory
3c. Configuration Options
3d. Notes on 64-bit Compatibility
4. Compile and Install the Software
5. Compile and Install the Device Driver
5a. Solaris Device Driver
5b. Linux Device Driver
5c. Cross-Building the Device Driver
6. Update Flash Memory
7. Initializing Boards
8. Creating a Software Package for Application Deployment
1. Install the DPT Boards
The software installation instructions that follow assume
that you have already installed the DPT boards in your
computer. The software may be installed prior to installing
the hardware but warning messages will be issued during the
device driver installation.
Install your DPT board(s) in appropriate PCI slots of your
computer. The system will identify the boards based on which
slots they located in. If you installing more than one DPT
board, the board found closest to the CPU will be named
"dpt0" and the others will be named in order, "dpt1",
"dpt2", etc. The ordering may vary depending on PCI bus slot
ordering.
Solaris systems save the device information for each board
when the device driver is installed and when new boards are
added to the system. The DPT boards generally will retain
their designations based on the slot they are in. The
exception is the case in which a DPT5 board is placed in a
slot that was once occupied by a DPT4 (or a DPT4 board in a
slot that was occupied by a DPT5). DPT5 boards include a PCI
bridge interface which makes them appear to be located in a
separate bus.
If a board is moved to a new slot it will be given a new
designation. For example, if a board originally installed in
slot1 and named "dpt0" is moved to the adjacent slot, its
new designation will be "dpt1". The system will still have a
record for a "dpt0" but the device is no longer installed.
It is recommended that the boards not be relocated after the
initial installation to avoid confusion.
On Linux systems the boards will always be designated in the
order they are found by the system, with the first found
being named "dpt0", etc.
2. Download (if necessary) and Extract the Software Distribution
If you are downloading the software package from our WEB
site, you will be downloading a tar-format archive
compressed using the GNU gzip program. The file name of
the package is in the form: dpt-<version>.tar.gz where
<version> denotes the version number of the software release
(e.g. dpt-1.5.7.tar.gz).
The companion gunzip is available for Solaris from several
software sites including Sunfreeware.com
<http://www.sunfreeware.com>. It is included with most Linux
distributions.
To unpack the downloaded version of the software
distribution, create your local directory and place the
archive file there. Then run the gunzip and tar programs
as shown:
# mkdir /usr/cac
# cd /usr/cac
# (download the software distribution to here)
# gunzip -c dpt-<version>.tar.gz | tar xvf -
If you are receiving the software on the CDROM there is no
need to download any additional software. Load the CDROM and
you can find the software packaged in tar format in the
unix or solaris directory of the CDROM named:
dpt-<version>.tar where <version> denotes the version
number of the software release (e.g. dpt-1.5.7.tar).
You can unpack the software onto your system by creating
your local directory, cd'ing into it and running the tar
program. For example:
# mkdir /usr/cac
# cd /usr/cac
# tar xvf /cdrom/unix/dpt-<version>.tar
The resulting, unpacked software distribution is placed in a
directory named dpt-<version> where <version> denotes the
version number of the software release. For example:
/usr/cac/dpt-1.5.7
An unpacked copy of the distribution is also available on
the CDROM in a sub-directory of the solaris directory
named dpt-<version>. This is provided as a backup to view
the original distribution files.
Note: The current software distribution includes support
for both Solaris and Linux in the same package. The
directory on the CDROM may be named either "solaris" or
"unix". Device driver code for Solaris and Linux are in
separate sub-directories of the unpacked software
distribution. The configuration step will configure your
package to use the proper device driver directory for the
system you run the configuration on.
3. Configure the Software
This step involves setting up the /environment/ and running
the configure script that is provided in the top level of
the distribution source directory.
3a. Choose the Installation Directory
Before configuring the software you should decide where the
software is to be built, installed to and used from. The
installation directory should be a common location
accessible by all users who will need to compile
applications and run support or diagnostic programs. The
default directory is /usr/cac. Once you have chosen this
directory you should set your environment to have a variable
named CAC and its value should be the name of your
installation directory.
Users of the software should include the directory,
$CAC/bin, on their program search path to enable running
the utility programs from any location in the filesystem.
This is usually done by appending to the PATH environment
variable, as described earlier. If the DPT diagnostic
programs are to be run on a regular basis, the directory,
$CAC/dpt/diag should also be included in the search path.
If you use the Bourne shell (sh or one like it) use the
following commands to set this variable (replace "/usr/cac"
with the directory you have chosen):
# CAC=/usr/cac
# export CAC
# PATH=$PATH:$CAC/bin
# export PATH
You can add those commands to your .profile file, or
whatever file your shell reads startup commands from, so
that the CAC variable and PATH will be set automatically the
next time you log on.
If you use the C-shell (csh or one like it) use the
following command to set this variable (replace "/usr/cac"
with the directory you have chosen):
# setenv CAC /usr/cac
# setenv PATH ${PATH}:$CAC/bin
You can add those command to your .login file so that the
CAC variable and PATH will be set automatically the next
time you log on.
3b. Choose the Build Directory
You may choose to configure and build the software directly
in the source directory or create a separate directory to
configure and build the software.
If you choose to build the software in the distribution
source directory run:
# cd /usr/cac/dpt-<version>
# ./configure --prefix=$CAC
If you choose the build the software in a separate directory
the commands are slightly different, specifying the path to
the configure program in the source directory.
# mkdir /usr/cac/dpt
# cd /usr/cac/dpt
# ../dpt-version/configure --prefix=$CAC
3c. Configuration Options
Some situations may require special configuration options.
These options are specified using parameters added to the
command line for the configure program. A complete list of
options is available by using the --help parameter:
# ./configure --help
This will generate a rather long list of options, many of
which are part of the standard GNU software system but are
irrelevant for the DPT4 software. The options of interest are:
--prefix=<PREFIX>
This option specifies a location to install the
compiled libraries and programs. If you chose an
installation directory other that the default of
/usr/cac you must use this option to specify
the installation directory.
--enable-smpci
Specify this option if you intend to make use of
smPCI expansion module support. Without this
option the smPCI support files are not installed.
--enable-hdlc
Specify this option if you intend to make use of
the HDLC parsing library on the host computer.
Without this option the HDLC library is not
installed.
--enable-devel
Do not use this option. It is used to include
programs used for development purposes. These
are programs used strictly for debugging or
initial board testing and are not included with
the software distribution.
--disable-diags
Specify this option if you do not wish to have
the diagnostic programs installed. Normally the
diagnostic programs are used for testing your
boards and installation and it is recommended
that the diagnostics be included in any
application development environment.
--disable-demos
Specify this option if you do not wish to have
the demonstration programs installed. The
demonstration programs are provided as
application examples and may also provide some
testing capability.
--with-readline=<option>
Some of the DPT diagnostic programs (currently
only dpdebug) utilize an external library for
controlling user input called readline. A
version of this library is included with the DPT
software release.
The --with-readline parameter allows the user
to specify the following readline options:
cac Use the readline library provided
by CAC. (default)
system Search for a readline library
installed on the system.
disable Disable the use of any readline library.
Many host systems have a readline or
compatible facility already installed. However
the use of the readline facility in the CAC
diagnostics may be incompatible with newer
distributions of the readline library.
Therefore, as of DPT release 1.4.1, the default
readline option is to compile and use the
version in the DPT software distribution.
--with-cflags=<flags>
This option allows you to specify additional
flags to the C compiler. It is primarily
intended to allow specifying a 32-bit or 64-bit
environment for the API library and support
programs.
See the "Notes on 64-bit Compatibility" below
for details.
This option does not affect compilation of the
device driver.
Special options for Solaris device driver configuration are:
--enable-solaris64
--enable-solaris32
Normally the Solaris device driver is
automatically configured to be compiled for the
type of kernel currently running (32-bit or 64-bit).
These options force the device driver
configuration to be compiled for the 32-bit or
64-bit kernel regardless of the currently
running system. This may be useful if you need
to prepare an installation that can be used with
a different kernel.
Special options for Linux device driver configuration are:
--with-majordev=<#>
Normally the Linux device driver allows the
Linux kernel to dynamically allocate its major
device number. If, for some reason, you want to
force the use of a specific major device number,
use this option to specify it at configuration
time.
Be sure not to specify a number that is reserved
for other devices in the system. Consult the
file, devices.txt, in the Documentation
directory of the Linux kernel source for a list
of devices with reserved major device numbers.
In any case, the various shell scripts used for
creating device nodes examine the contents of
procdevices to determine the major device
number for the DPT driver.
--with-numboards=<#>
This option is used to specify the number of DPT
boards you expect to install in your system. The
value is used by the shell script, makedptdev,
and the system init-script, cacdpt.sh, to
determine how many device entries to create in
the /dev directory. The default is to create
entries for 4 DPT boards.
--disable-vsyms
This option is used to disable compiling the
device driver with version information for
Kernel symbols. In most cases this should be
left enabled. However, under certain
circumstances the Kernel symbol versions
obtained from the installed Kernel source may
not match those of the running Kernel. Symptoms
of this situation are unresolved symbol errors
when loading or installing the device driver. If
you experience these types of errors, the best
solution is to repair the discrepancy between
the loaded Kernel and the Kernel source. But you
can also try re-configuring and re-building the
device driver using this option.
--with-ksrcdir=<dirname>
This option is used to specify the location of
the kernel source or build directory. It is
available with release versions 1.4.6 or higher.
By default this directory is determined by the
version of the currently running Linux kernel at
the time the configure program is run. For Linux
2.4 kernels, it is usually found in
/usr/src/linux-<version>. For Linux 2.6
kernels this directory will be the module build
directory which is usually found in
/lib/modules/<version>/build.
The source or build directory may be specified
to be that of a different version of the Kernel
to allow building the device driver to be
installed on a system running a different
version of the Linux kernel. There are some
additional requirements and limits for the
ability to cross-build the device driver,
described below.
--with-kmoddir=<dirname>
This option is used to specify where the device
driver module is installed. It is available with
release versions 1.4.6 or higher.
The module installation location setting affects
both where the Makefile installs the module and
where the boot script looks for it. By default
the directory is determined by the currently
running kernel version at installation time and
at boot time and is located in
/lib/modules/<version>/misc.
Because the default location is determined at
installation or boot time, it is not usually
required to specify this option when configuring
the device driver to be built for a different
kernel version.
--with-rcdir=<dirname>
--with-initdir=<dirname>
These options are used to specify the location
of the system init-scripts and the symbolic
links to them that are used to control how and
when the scripts are run. By default the
configure script searches for the usually
locations: /etc/rc.d/init.d, /etc/init.d and
/etc/init.d/rc.d.
If neither of those exist or you need to specify
another location, use the --with-rcdir option
to name the parent directory where the
directories rc2.d, rc3.d, rc5.d, etc. are
found. If that directory does not also include
the directory named init.d then also use the
--with-initdir option to specify the parent
directory of the init.d directory.
As an example, for a Solaris system running on a 64-bit
Sparc platform, and the GCC compiler, the configure command
would be:
# ./configure --prefix=$CAC --with-cflags=-m64
For a Linux system in which you expect to install at most 2
DPT boards, the configure command would be:
# ./configure --prefix=$CAC --with-numboards=2
3d. Notes on 64-bit Compatibility
The DPT software API and device driver for Linux and Solaris
are 64-bit compatible. Configuring the software to be
compiled for 64-bit varies depending on the operating system
and platform.
For Linux on Intel x86 and ia64 platforms, the GCC compiler
is generally installed with default settings to match the
architecture and installation. For example, when the Red Hat
64-bit installation is loaded on a system with x86 EMT-64
processors, it will compile 64-bit code by default.
The device driver must be built to match the data width of
the kernel. However, if you wish, you can build the API for
32-bit applications. This can be done by using the following
option with the configure script:
--with-cflags=-m32
For Solaris, the device driver must be compiled as a 64-bit
module if the system supports sparc-v9 or amd64
architectures and is running the 64-bit kernel. The
configure script handles this by automatically providing the
appropriate compiler flags for the device driver. However,
by default, the user code (API and support programs)
compilation is done for 32-bit code, regardless of the
platform and kernel mode. It is not affected by the
enable-solaris64 option to the configure script.
To compile the user code for 64-bit applications use one of
the following options with the configure script (depending
on the compiler and platform).
Compiler Platform Configure Option
Gnu GCC any --with-cflags=-m64
Sun Studio CC Sparc (v9) --with-cflags=-xarch=v9
Sun Studio CC x86-64 / AMD64 --with-cflags=-xarch=amd64
4. Compile and Install the Software
Once the configure program has been run you may compile the
software. To do this, run the following command in the
build directory, where you ran the configure script:
# make
This will compile the various libraries and programs that
comprise the DPT4 software. Excluded from the default build
is the device driver. The device driver is built and
installed as a separate operation, described below.
Once the API and programs have successfully compiled they
can be installed by running the command:
# make install
This will install the software into the following directories:
directory files installed
$CAC/lib the DPT API library and other libraries used
by the software
$CAC/include header files required for applications
that use the API
$CAC/bin support and utility programs
$CAC/dpt/diag diagnostic programs
$CAC/dpt/demos demonstration programs
$CAC/dpt/flash data files containing flash data and
PLL configuration files
$CAC/smpci support files for smPCI modules
(if configured with --enable-smpci)
DPT software versions prior to 1.4.3 installed the
diagnostic and demonstration programs in $CAC/bin along with
the utility programs. If you are upgrading from a version
prior to 1.4.3 you should run the following command before
running make install to remove any old program version
from $CAC/bin:
# make uninstall
This should be run using the new software release because
this procedure did not work properly in some older versions.
5. Compile and Install the Device Driver
The device driver is installed separately from the libraries
and support programs.
Note: This step must be performed with root privileges.
5a. Solaris Device Driver
The Solaris device driver has been tested with Solaris 8, 9
and 10 on Sparc and x86 (IA32) platforms.
To compile and install the Solaris device driver, change
your current directory to the soldev directory of the
software distribution and run make install-drv. For example:
# cd /usr/cac/dpt-<version>/soldev
# make install-drv
This will compile the driver code and run the system
commands to install the driver in your system. The device
driver installation process includes installing a system
start-up script, dpinit.sh, that will automatically
initialize the DPT boards as part of the system boot-up
procedure.
Note: a 64-bit capable compiler is required if you are
building the device driver for a 64-bit Solaris kernel.
Compatible 64-bit compilers include Sun Studio compiler and
GCC, version 3.2 or higher.
5b. Linux Device Driver
The Linux device driver supports 2.4 and 2.6 kernel versions
on Intel x86 (IA32) and Itanium (IA64) platforms. Kernel
version 2.4 has been tested with Red Hat releases 7.3
through Enterprise Linux Version 3. Kernel version 2.6 has
been tested with Red Hat Enterprise Linux versions 4 and 5.
Compiling the Linux device driver for 2.4 version kernels
requires the Kernel source to be installed. This is normally
installed with the kernel-source RPM. Check the
installation using the command:
# rpm -q kernel-source
Compiling the Linux device driver for a 2.6 version kernel
requires that the appropriate kernel development package be
installed. The appropriate package depends on the type of
the kernel you are running and, perhaps somewhat, on which
Linux distribution is used.
For Red Hat Enterprise Linux 4, the choices are normally
either the kernel-devel or kernel-smp-devel package (for
the single processor or SMP variant of the kernel,
respectively). Both are usually installed if you select
Kernel Development as one of the packages to install.
If you are using the hugemem variant of the kernel you
should install the kernel-hugemen-devel package.
For Red Hat Enterprise Linux 5, the kernel-devel package
is installed by default and will work unless you have
installed one of the special kernel variants, such as the
PAE enabled kernel. In this case you need to also install
the kernel-pae-devel package.
You can usually determine which kernel varint is currently
running using the uname -r command. Check the installation
using the commands appropriate for the kernel variant you
are using. For example:
# rpm -q kernel-devel
# rpm -q kernel-smp-devel
or
# rpm -q kernel-pae-devel
If the rpm command displays a message saying the package
is not installed you must install the required RPMs from
your Linux distribution. If your kernel was installed using
other means than the RPM system, you may have to use the
--with-ksrcdir option when running the software
configuration script to specify the location of the
installed kernel source or build directory.
To compile and install the Linux device driver, change your
current directory to the linuxdev directory of the
software distribution and run make install-dev. For example:
# cd /usr/cac/dpt-<version>/linuxdev
# make install-dev
This will compile the driver code to create the loadable
kernel module, load the module and create device entries in
the /dev directory. It also copies the driver module into
the /lib/modules directory of the system for use by the
boot-up initialization script (see below). The exact
location depends on the current kernel version:
/lib/modules//kernel-version//misc
As of version 1.4.1, the device driver will be properly
compiled for SMP if the system is running in SMP mode. When
the driver is installed on a system running in SMP kernel
mode the module is copied to the /lib/modules/directory for
SMP modules. To install the module for both SMP and non-SMP
kernel modes, after installing the driver while running in
the current kernel mode (SMP or non-SMP), reboot the system
in the other kernel mode and run:
# cd /usr/cac/dpt-<version>/linuxdev
# make clean
# make install-dev
This will force the driver module to be rebuilt and
installed for the new kernel mode. Now both versions will be
installed in the appropriate modules directories. For example:
/lib/modules/2.4.18-3smp/misc/dptdrv.o - the SMP driver
/lib/modules/2.4.18-3/misc/dptdrv.o - the non-SMP driver
When installing a new device driver on a system that has a
DPT4 device driver already loaded the module must be
unloaded before the new one can be installed. To do this,
run this command prior to the make install-dev command:
# make unload-drv
If you need to uninstall the device driver completely, run
the command:
# make uninstall-dev
Whenever the device driver is loaded or re-loaded, the
dpinit program must be run to initialize the DPT boards
(see below).
The device driver module must be re-loaded and the device
nodes re-created whenever the system is rebooted. To
automate this process you can install the cacdpt.sh
initialization script to be included in the system's boot-up
initialization procedure. It is recommended that this be
installed after you have verified that the driver loads and
operates properly in your system and you can successfully
run the dpinit program.
To install the DPT initialization script run the command:
# make install-rc
This will copy the cacdpt.sh shell script to the system's
init.d directory and create links in other RC directories to
run the boot-up sequence when the system boots into
run-level 3 or 5 and to run the shutdown sequence when the
system switches to run level 6 or 0 (reboot or halt).
The DPT initialization script's boot-up sequence loads the
device driver module, creates device entries in /dev and
runs the dpinit program to start the embedded code on the
DPT boards. The script loads the device driver module from
the appropriate modules directory for the kernel mode that
is running (i.e. SMP or non-SMP).
During system start up, the init-script will be indicated by
the message, "Starting cacdpt". It may pause for several
seconds while initializing the DPT boards, especially if
FPGA's on smPCI expansion modules are being configured.
Check the system log file (/var/log/messages) for details on
the initialization sequence.
The script's shutdown sequence halts the embedded code on
the DPT boards to stop interrupts and other automated PCI
activity.
If you need to remove the DPT init-scripts from the system
run the command:
# make uninstall-rc
5c. Cross-Building the Device Driver
The API library and support programs are generally
compatible across versions of the operating system, although
not all possible combinations have been tested. Note
however, that separate builds are always required for
Solaris on Sparc platforms, Solaris on x86 platforms and
Linux on x86 platforms.
Device drivers are generally much more dependent on the
specific version of an operating system. The default
configuration and build for the device driver assumes that
the device driver is to be installed for the currently
running version of the operating system on the current
hardware platform.
Cross-compiling the device driver, building it for
installation on a different version of the operating system
is supported to a limited extent by the configure program.
Compiling a device driver for a different hardware platform
is not supported.
When cross-compiling the device driver to be installed later
later for a different version of the kernel, do not use the
make install-dev command as shown in the previous sections.
Instead, run
# make driver
This will compile the device driver to produce the loadable
module without attempting to install it on the current system.
The Solaris device driver has not typically been dependent
on the version of the operating system. For example, a
device driver built on Solaris 8 can be installed on a
system running Solaris 9. The primary dependency for the
Solaris device driver is whether or not it is build for a
kernel that supports 64-bit addressing. A device driver
built for the 32-bit version of the Solaris kernel will not
load for the 64-bit version of Solaris, and vice-versa. If
it is necessary to build a Solaris device driver for they
kernel type (32-bit or 64-bit) that is not the currently
running type, one of the configuration options,
--enable-solaris64 or --enable-solaris32 may be used.
Linux kernel modules are much more dependent on the kernel
version and, in some circumstances, on the version of the
compiler used.
The main requirement for compiling the Linux device driver
for a different version of the kernel is to have the kernel
source for the target version installed. This is most easily
accomplished by installed the appropriate RPM package; the
kernel-source package for 2.4 kernels, or the kernel-devel
and kernel-smp-devel packages for 2.6 kernels. The
--with-ksrcdir configuration option may be used to direct
the configuration to the kernel source (or build) directory
for the desired target kernel version. Note: this option is
available in release versions 1.4.6 or higher.
For 2.4 kernels, the kernel source directory must be
configured and build up through the step of running
make dep in order to have all the required module version
information available.
This works on its own for building the Linux device driver
for various kernel versions with the same Red Hat Linux
release family (i.e. Red Hat 8, Red Hat 9, Enterprise Linux
3 and Enterprise Linux 4). Certain problems arise when
attempting to build the device driver for a different Linux
distribution. For example, to compile the driver for Red Hat
Enterprise Linux 4 (a 2.6 kernel) while running Red Hat
Enterprise 3, the version of the GCC compiler from the Red
Hat Enterprise Linux 4 distribution must be used, and
vice-versa. To specify the compiler, you should specify the
full path to the gcc program as the environment variable,
CC. For example:
# setenv CC /usr/local/rhel4gcc/bin/gcc
# make driver
or
# CC=/usr/local/rhel4gcc/bin/gcc
# export CC
# make driver
Compiling a device driver for Reh Hat 8 or Red Hat 9 while
running newer Red Hat distributions may not work at all
because of various differences in how the kernel is build
and installed.
6. Update DPT Flash Memory
The DPT boards include flash memory which stores FPGA
configuration data and program code for the MIPS processor.
This software release may include updates for the flash data.
To ensure that the DPT boards are up to date run the
dpflashup program from a shell window as shown below:
# dpflashup all
The program will compare the code versions in the flash of
each DPT board with the versions supplied with the new
software release. Any new versions will be loaded in the
flash memory.
In some cases, depending on which flash data is updated, the
changes will not take effect until the system is
power-cycled. The dpflashup program will display a message
if a power-cycle is required.
7. Initializing DPT Boards
The channelization functionality of DPT boards will not work
before the DPT boards are initialized.
From a command shell window run the dpinit program as
shown below.
# dpinit
The dpinit program starts the embedded code running on all
of the DPT boards found in the system. It also configures
FPGA's on any installed smPCI expansion modules. For each
board initialized the program will display the word "Done".
It takes a few seconds for the embedded code to initialize
the channelization software on the board.
The device driver installation process includes installing a
system start-up script that will automatically initialize
the DPT boards as part of the system boot-up procedure.
Although, it does not hurt to run the command more than
once. When run a second time it first halts the embedded
code and then restarts it to do a full initialization.
8. Creating a Software Package for Application Deployment
You can create a software package that includes the
necessary files for using and maintaining DPT boards on
non-development systems. This is especially useful for
deployment systems that do not have software development
tools. To create the software package, run the following
command in the directory where you configured and compiled
the software:
# make package
This will gather the necessary files, create device driver
installation scripts, and create a archive named
dpt-pkg-<version>.tar. For example: dpt-pkg-1.5.7.tar. The
package includes the following file groups:
_directory_ _package files_
./bin support and utility programs
./dpt/soldev Solaris device driver and installation
scripts (Solaris systems only)
./dpt/linuxdev Linux device driver and installation
scripts (Linux systems only)
./dpt/flash data files containing flash data and PLL
configurations
./smpci support files for smPCI modules (if
configured with --enable-smpci)
The package must be installed on systems of similar
configuration as the system the software was configured and
compiled on. Solaris systems must use the same kernel
address width (32-bit or 64-bit) as the build system or as
specified to the configure command. Linux systems must be
running the same kernel version. Additionally, the package
should be installed in the same directory name specified by
the --prefix option to the configure command, otherwise
the boot-up initialization scripts will not find the
dpinit program. It is also recommended the users on the
target systems include the $CAC variable in their
environment to facilitate using the dpflashup program, if
necessary.
To install the package on target systems, create the
top-level installation directory (same as the specified
prefix) and extract the package archive. For example:
# mkdir $CAC
# tar xf dpt-pkg-1.5.7.tar
To install the device driver and boot-up initialization
script on the target system, run the following commands as
the /root/ user:
# cd $CAC/dpt/soldev
# ./install.sh
or, for Linux systems,
# cd $CAC/dpt/linuxdev
# ./install.sh
Run the dpinit program ($CAC/bin/dpinit) to make sure the
boards and device driver are functioning properly. Should it
be necessary to uninstall the device driver from the target
system, run the uninstall.sh script in the appropriate
device driver directory ($CAC/dpt/soldev or $CAC/dpt/linuxdev).
DPT Software Installation for Windows Systems
A Windows Installer application and data files are provided for
Windows installations. Note that "Administrator" privileges are
required to install the device driver.
Specific, step-by-step instructions are provided below in the
following sections:
1. Install the DPT Boards
2. Download and Extract the Software Distribution
3. Run the Installer Program
4. Install the Device Driver
4a. Install Device Driver for a First Time Installation
4b. Updating Device Driver from a Prior Installation
5. Update Flash Memory
6. Initializing Boards
1. Install the DPT Boards
The software installation instructions that follow assume
that you have already installed the DPT boards in your
computer. The software may be installed prior to installing
the hardware but some of the descriptions here may vary from
your experience.
Install your DPT board(s) in appropriate PCI slots of your
computer. When you first boot your system with the boards
installed and before you have installed the DPT software, a
"New Hardware Found Wizard" dialog will appear. Ignore this
dialog for now and proceed to install the software.
The system will identify the boards based on which slots
they are located in. If you are installing more than one DPT
board, the board found closest to the CPU will be named
"dpt0" and the others will be named in order, "dpt1",
"dpt2", etc. The ordering may vary depending on PCI bus slot
ordering.
On Windows systems the boards will always be designated in
the order they are found by the system, with the first found
being named "dpt0", etc.
It is recommended that the boards not be relocated after the
initial installation to avoid confusion.
2. Download (if necessary) and Extract the Software Distribution
If you are downloading the software package from our WEB
site, you will be downloading a zip formatted archive. The
file name of the package is in the form: dpt_<version>.zip
where <version> denotes the version number of the software
release (e.g. dpt_157.zip is the archive for version 1.5.7).
Download the distribution archive file to some temporary
folder and unpack it. Most Windows installations include a
program for unpacking ZIP files. Otherwise use a program
such as Stuffit Expander from Aladdin Systems
<http://www.stuffit.com/expander/index.html> or winzip
from Winzip.com <http://www.winzip.com>
If you are receiving the software on the CDROM there is no
need to download any additional software. Loading the CDROM
should, in most cases, open a WEB browser to a page from the
CDROM providing you with links to the software installer and
documentation. In fact, you may be reading this document
from the CDROM.
The distribution archive is found in the win2k directory
of the CDROM named: dpt_<version>.zip where <version>
denotes the version number of the software release (e.g.
dpt_157.zip). An unpacked copy of the distribution is also
available on the CDROM in a sub-directory of the win2k
directory named dpt_<version>. You may extract the files
from the ZIP archive to your local hard drive or run the
installer directly from the CDROM if you prefer.
Whether you have extracted the software archive to your
local hard drive or you choose to use the installer directly
from the CDROM, you should see the following files in the
folder where the installer is:
DPT4_API.msi
Data.Cab
instmsiw.exe
setup.exe
setup.ini
3. Run the Installer Program
Note: To perform a clean installation, without remnants of
previous versions, you should first remove the previous
version. If your previous version is 1.1.1 or higher you can
remove it using the "Add/Remove Programs" control panel. For
earlier versions you will have to manually remove the files
from the folder in which you installed the software taking
care not to delete any programs or other files you may have
created.
For CDROM distributions you may run the installer directly
from a link on the "WEB" page that appears. If you are
installing from the distribution folder double-click the
setup.exe file to launch the installer.
It may take a few moments for the Windows Installer to
initialize. In fact, the preliminary message boxes may
disappear for several seconds before the installer actually
starts up. Wait for the installer dialog to appear saying,
"Welcome to the InstallShield Wizard for CAC DPT4 Software".
Click on the "Next" button. Read the license agreement,
select the radio button to accept the terms and click on the
"Next" button.
The next dialog asks about the destination folder for the
installed software. The recommended destination is c:\cac.
You have the opportunity to select a different location.
The installer will now check your current program search
path and environment variables and display a dialog named
"Path and Environment Settings" with recommended changes. If
no changes are required this dialog will be skipped.
The next dialog asks you to choose a "Setup Type". Most
users should choose the "Typical" setup which includes the
commonly used components. The "Complete" setup will install
everything and may be used if you desire to have a debugging
version of the API, source files and support for smPCI
modules. The "Custom" setup allows you to choose the
additional components. If you selected "Custom Setup" the
next dialog asks you to select the components using pulldown
menus.
The next dialog after selecting the setup type and
components is named "Ready to Install the Software". This
gives you a chance to go "Back" and modify your installation
parameters. When you are ready to install the software click
the "Install" button. The installer will now copy the DPT4
software files to the chosen destination and setup some
items in the system registry.
When the installation is complete, the final dialog provides
the opportunity to read information about installing the
device driver. This information is also included here but
the file displayed by the installer may contain updated
information. Click the "Finish" button to terminate the
Windows Installer.
4. Install the Device Driver
The instructions provided here are for Windows XP or later,
32-bit or 64-bit. When installing on Windows 2000, please
consult the device driver installation instruction
instructions that can be viewed from the installer at the
end of the installation.
As of release version 1.5.7 the device driver is
authenticated with a digital signature and must be installed
or updated using the Windows Device Manager.
4a. Install Device Driver for a First Time Installation
If this is the first time a DPT software has been installed
in your system, and DPT boards are installed in the
computer, Windows will have opened a "Found New Hardware
Wizard" dialog box when you first logged on. Click on the
"Cancel" button of this wizard, if you have not already, to
abort the wizard for the first DPT board. Cancel any others
that appear for additional boards.
Follow the steps below to install the device driver using
the Windows Device Manager. The DPT device driver installation
will deploy an update of the Windows Driver Foudation if the
system requires it. A reboot will be required after the
driver is installed for all of the DPT devices.
1. Open the Control Panel from the Windows "Start" button,
select "Settings" then "Control Panel".
2. From the "Control Panel" window select and run the
"System" control panel. Depending on the version of
the OS, this will open a window with tabs titled,
"System Properties", or a windows with links,
titled, "System".
3. For the "System Properties" window, choose the tab
labeled "Hardware" and then click on the "Device Manager"
button.
For the "System" window with links, click on the link for
"Device Manager" under the "Tasks" heading.
4. The "Device Manger" window lists the devices currently
installed in the system. The list should include an item
named "Other devices".
Expand the list, if necessary, by clicking the "+" to the
left of "Other devices". This should reveal one or more
devices named, "PCI Device".
5. For each "PCI Device" listed, right click on the device
and select "Update driver" or "Update driver software"
command from the menu that appears. Depending on the
OS version, this will open a "Hardware Update Wizard"
or "Update Driver Software" window.
6a. For the "Hardware Update Wizard" window, you may be
asked about connecting to Windows Update".
Select "No not this time" and click the "Next" button.
In the next pane, choose "Install from a list or specified
location". Click "Next".
In the next pane, choose "Search for the best driver...".
Unselect "Search removable media...". Select "Include this
location in the search".
6b. For the "Update Driver Software" window, click on
"Browse my computer for driver software".
6c. For either window (OS) type continue by clicking the
"Browse" button and navigate to select
"C:\cac\dpt\driver" for 32-bit systems,
or
"C:\cac\dpt\driver64" for 64-bit systems.
If you chose a different location to install the DPT
software, replace "C:\cac" with the folder you chose.
Click "Next" and the system will install the driver
for the device selected in step 5.
If the Windows Driver Foundation requires an update
you will be notified that the system has to be
rebooted before the device can be used. Delay
rebooting until the device driver has been installed
for all of the DPT boards.
7. Repeat steps 5 and 6 for all of the "PCI Device" entries
in the "Device Manager" window. If any of them are not DPT
boards, the driver won't load.
8. Close the "Device Manager", "System Properties" and
"Control Panel" windows.
9. If an update for the Windows Driver Foundation had
to be deployed you may be presented with a dialog
box to reboot the system. You should do that now.
4b. Updating Device Driver for Upgrades from a Prior Installation
If you are updating the DPT software from a previous
software release please follow the procedure, below, to
update the device driver using the Device Manager:
1. Open the Control Panel from the Windows "Start" button,
select "Settings" then "Control Panel".
2. From the "Control Panel" window select and run the
"System" control panel. Depending on the version of
the OS, this will open a window with tabs titled,
"System Properties", or a windows with links,
titled, "System".
3. For the "System Properties" window, choose the tab
labeled "Hardware" and then click on the "Device Manager"
button.
For the "System" window with links, click on the link for
"Device Manager" under the "Tasks" heading.
4. In the list of device types or categories there should
be an entry named "CACDSP".
Expand the list by clicking the "+" to the left of "CACDSP".
This should reveal one or more devices named, "DPT4"
and/or "DPT5/6".
5. For each DPT device listed, right click on the device
and select "Update driver" or "Update driver software"
command from the menu that appears. Depending on the
OS version, this will open a "Hardware Update Wizard"
or "Update Driver Software" window.
6a. For the "Hardware Update Wizard" window, you may be
asked about connecting to Windows Update".
Select "No not this time" and click the "Next" button.
In the next pane, choose "Install from a list or specified
location". Click "Next".
In the next pane, choose "Search for the best driver...".
Unselect "Search removable media...". Select "Include this
location in the search".
6b. For the "Update Driver Software" window, click on
"Browse my computer for driver software".
6c. For either window (OS) type continue by clicking the
"Browse" button and navigate to select
"C:\cac\dpt\driver" for 32-bit systems,
or
"C:\cac\dpt\driver64" for 64-bit systems.
If you chose a different location to install the DPT
software, replace "C:\cac" with the folder you chose.
Click "Next" and the system will install the driver
for the device selected in step 5.
7. Repeat steps 5 and 6 for all of the DPT entries in the
"Device Manager" window.
8. Close the "Device Manager", "System Properties" and
"Control Panel" windows.
5. Update DPT Flash Memory
The DPT boards include flash memory which stores FPGA
configuration data and program code for the MIPS processor.
This software release may include updates for the flash data.
To ensure that the DPT boards are up to date run the
dpflashup program from a command shell window.
Click on the Windows "Start" button and select "Run". In the
dialog that opens there is a text line labeled "Open" into
which you should type the word, "cmd", (without the quotes).
Then click the "OK" button. This should open a command shell
window.
In the command shell window run the dpflashup program by
typing
C:\> dpflashup all
Hit the "Enter" key on the keyboard. The program will
compare the code versions in the flash of each DPT board
with the versions supplied with the new software release.
Any new versions will be loaded in the flash memory.
In some cases, depending on which flash data is updated, the
changes will not take effect until the system is
power-cycled. The dpflashup program will display a message
about this if a power-cycle is required.
6. Initializing DPT Boards
The channelization functionality of DPT boards will not work
before DPT boards are initialized.
From a command shell window run the dpinit program as
shown below.
C:\> dpinit
The dpinit program starts the embedded code running on all
of the DPT boards found in the system. For each board
initialized the program will display the word "Done". It
takes a few seconds for the embedded code to initialize the
channelization software on the board.
This program needs to be run each time the system is turned
on. You may want to add the dpinit command to a startup
script for your login session. It does not hurt to run the
command more than once. When run a second time it first
halts the embedded code and then restarts it to do a full
initialization.
Download Driver Pack
After your driver has been downloaded, follow these simple steps to install it.
Expand the archive file (if the download file is in zip or rar format).
If the expanded file has an .exe extension, double click it and follow the installation instructions.
Otherwise, open Device Manager by right-clicking the Start menu and selecting Device Manager.
Find the device and model you want to update in the device list.
Double-click on it to open the Properties dialog box.
From the Properties dialog box, select the Driver tab.
Click the Update Driver button, then follow the instructions.
Very important: You must reboot your system to ensure that any driver updates have taken effect.
For more help, visit our Driver Support section for step-by-step videos on how to install drivers for every file type.