Gentoo Wiki


This article is part of the HOWTO series.
Installation Kernel & Hardware Networks Portage Software System X Server Gaming Non-x86 Emulators Misc

This HOWTO deals with installing Xilinx ISE WebPack on Gentoo Linux with a 2.6 kernel. ISE WebPack is the no-cost version of the Xilinx ISE toolset for programming and downloading Xilinx FPGAs and CPLDs. Much of this information may also be relevant to installing the full Xilinx ISE.

ISE WebPack is supplied in binary form only. It is provided for the x86 (i.e., 32-bit) version of RHEL, and Xilinx does not support it on other Linux distributions or architectures. This HOWTO is intended to bridge the support gap and permit you to run ISE WebPack under x86 or amd64 Gentoo Linux. The HOWTO was originally written for v8.1i of the WebPack and for Gentoo circa 2006.1, but it has been updated to reflect WebPack v9.2i and Gentoo as of 2007-12-28. Since the HOWTO is primarily for new installations, information about older releases is secondary, although it is still present.

ISE WebPack is a GUI application suite which can also control any of several proprietary peripherals of the type known as a "programming cable" or just "cable." A cable connects your Linux host system to a development board that has one or more Xilinx FPGAs, PROMs, or CPLDs. The problems associated with running WebPack on Gentoo naturally divide into two parts:

The HOWTO is therefore divided into two main sections that address the two parts separately.


Installing the Xilinx Webpack Application Suite

There are two approaches to installing and running the Xilinx Webpack application suite. There are advantages and disadvantages to each approach. You may decide to try both of them. The traditional approach is to install and run the suite as it is supplied by Xilinx: as an integrated development environment with the applications run from the common GUI supplied by Xilinx. Almost all of the documentation available from Xilinx and available on the web assumes that you will run the ISE in this fashion. The advantages of this approach are that you can use Xilinx's well-thought-out GUI and its documentation. The disadvantages are that the interface from the main GUI to the actual application engines is somewhat fragile and tends to break in a non-standard Linux implementation. It is also more complex to replace individual Xilinx helper applications with Opensource equivalents. The alternative is to run the individual helper applications from the command line or from a separate IDE such as Eclipse. This approach is not yet well-documented, but it is in use by several developers. Until it is better documented, you should probably not try it unless the traditional approach fails for you. This HOWTO currently assumes that you will be using the Xilinx GUI.


(Note for amd64 systems: Prerequisite applications can be amd64. However, since WebPack is a 32-bit application, the prerequisite libraries are the 32-bit versions -- can an amd64 person please expand this?)


Your system must either not install TCL, or your TCL must be older than 8.4.15. If your TCL is too new, ISE will print error messages and then fail. Check the version with:

emerge -s tcl

Then if present and too new:

emerge --unmerge tcl

Finally, if you need tcl for other applications:

emerge -u =tcl-8.4.14

A better way is to export LD_PRELOAD variable before ise start. Here is my startup script:

export DISPLAY=":0"
export PRINTER="lj4l"
export LC_ALL=
export LANG=
export LANGUAGE=
export LD_PRELOAD="/opt/Xilinx/10.1/ISE/lib/lin/"
source /opt/Xilinx/10.1/ISE/

It is working even if portage now contains not any older version of tcl than the mentioned 8.4.15.


It seems that at least WebPack version 10.1 uses the newer glibc API and so this steps are not neccessary when using that version. Older versions of the WebPack use the old glibc-2.0 API, so your glibc must be compiled with backward compatibility. The easiest approach is:

echo "sys-libs/glibc glibc-compat20 -nptlonly" >>/etc/portage/package.use
emerge -DuN glibc

This takes awhile. Failure to do this causes Webpack to fail to run certain critical subsidiary processes, causing secondary windows to fail to appear: these failures are usually silent: you will not see an error message, but the window will not appear. unfortunately, the two relevant USE flags, glibc-compat20 and nptlonly, are present in glibc-2.5 and in glibc 2.7, but not ins glibc 2.6. Therefore, you may need to unmask glibc 2.7 or down-rev to glibc-2.5 to use this option. If you prefer not to do this, See this description for a cleaner but more complicated alternative.


You will need openmotif, and Webpack 9.2i or below insists that the version must be < 2.3.0. As of 2008-02, Webpack will run with the current version of openmotif if you assure it that it is actually the older version.

Since openmotif < 2.3.0 is now blocked, you have to install the current openmotif version and manually create the symlinks for the old lib

cd /usr/lib/openmotif-2.3/
ln -s
ln -s
ln -s ../
ln -s ../

Other prerequisites

You will also need xorg-x11 and acroread. Without acroread, the help screens may not appear. About xorg-x11: The entire Gentoo community shifted to xorg-x11 over the course of 2007. If you are still using the older x11, Please update this HOWTO, or discuss this on the talk page.

emerge xorg-x11 # we assume you already did this!
emerge acroread
For Webpack v8.1i, you additionally need portmap. Users report that without portmap, the install takes much longer to complete.

ISE uses IP to talk to its components, so if you are running a firewall, you need to configure it to allow traffic from localhost to localhost.


xhost +   #as the regular user, to let root use the X display
su        #must be root to install
export DISPLAY=:0  #install script needs this?
/etc/init.d/portmap start # speeds up the install?
Error: Cannot run process - /opt/xilinx92i/.xinstall_driverscript
insmod: error inserting '/lib/modules/misc/windrvr6.o': -1 Invalid module format
cp /opt/Xilinx92i/ /usr/local/bin/startise #note: for 10.1, is ../ISE/ instead
echo "export DISPLAY=:0" >> /usr/local/bin/startise  #note 1
echo "exec ise" >> /usr/local/bin/startise
chmod +x /usr/local/bin/startise


You can (and should) run the WebPack ISE as a regular user, not as root. To start the ISE:


You should be able to now perform all ISE operations except for those that require the use of a download cable. It is a good idea to try out your installation at this point before proceeding to the cable driver portion of the installation.

Information on installing on other Linux Distributions

(note: don't forget to check the discussion page)

Cable interfaces

FPGA Downloader Installation Methods

The WebPack ISE creates binary image files for download to the target system. The ISE can then invoke its own internal downloader, IMPACT, to load the binary onto the target, or you may use a separate program. In addition, there are two ways to connect IMPACT to the actual hardware on your PC, so there are three approaches. There are advantages and disadvantages to each approach. They are listed here in their historical order of development. You should pick one approach. Installation for each method is described in its own section later in the document.

Method 1: kernel modules

The Xilinx-approved method for use on supported RHEL Linux is to install two Linux kernel drivers that they supply. The advantage of this method is that most existing documentation assumes this approach. The disadvantage is that the drivers tend to not work with non-RHEL Linuxes and to break from version to version. Since you are reading the Gentoo Xilinx HOWTO, you are already not going to be supported by Xilinx. Xilinx is considering providing open source kernel modules to replace the binary-only modules. Until these drivers are in the main kernel tree, you will probably need to recompile them and re-install them each time you update your kernel.

Method 2: Xup and XC3Sprog

You can use a separate GPLed application named XC3Sprog to download the FPGA images via a parallel port cable. For a USB cable (at least for the Spartan 3E starter kit) you can use Xup to reprogram the USB logic on the board and then use a custom version of XC3Sprog to download the FPGA images. The advantage is that this is completely separate from the WebPack installation, and for USB at least, there is a potential to later actually use the USB cable to communicate with your FPGA system. One disadvantage is that it takes awhile each time you switch back and forth between IMPACT and Xup, but this will not matter if you decide to stick with Xup. A minor disadvantage is that a download takes twice as long (4 seconds instead of 2 seconds) because Xup has not yet been optimized. The third disadvantage is that it is not integrated with the ISE.

Method 3: User-space cable driver library

You can use IMPACT without installing the kernel drivers, by installing a "wrapper library." this approach uses a library which provides the API that IMPACT expects to use, but then invokes the user-space IO libraries instead of the kernel modules. The advantages are that the ISE and IMPACT run exactly as expected and at full speed, and the system should work with any kernel including 64-bit kernels.

Installing Cable Driver Kernel Modules

This section deals with installing modules on a 32bits distribution. The Webpack and ISE 8.1 and 8.2 distributions do not include 64-bit cable drivers. However, 64-bit cable drivers are available from the Xilinx ftp site: [1]

Xilinx modules

Base installation (works with (works with 2.6.21-suspend2-r6) (bugfixed for Ubuntu 7.10) (for x86_64) (for Ubuntu 7.10 x86_64)

insmod /lib/modules/misc/windrvr6.ko
set -- $(grep windrvr6 /proc/devices)
rm -f /dev/windrvr6
mknod -m 0666 /dev/windrvr6 c $1 0
insmod /lib/modules/misc/xpc4drvr.ko
set -- $(grep xpc4drvr /proc/devices)
for i in 0 1 2 3
        rm -f /dev/xpc4_$i
        mknod -m 0666 /dev/xpc4_$i c $1 $i

An alternative to setting permissions is adding a permission rule to UDEV: (FIXME please confirm)

mkdir /etc/udev/permissions.d 
echo windrvr6:root:root:0666 >> /etc/udev/permissions.d/50-udev.permissions
Using udev

If you don't use hotplug you have to use udev. This is also useful if you don't want to use the rc.local script.

#SUBSYSTEM=="module",           OPTIONS="ignore_device"
ENV{UDEVD_EVENT}=="1", ACTION=="add", SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="0007",  RUN+="/sbin/fxload -v -t fx2  -I /etc/hotplug/usb/xusbdfwu.fw/xusbdfwu.hex -D $env{DEVNAME}"
ENV{UDEVD_EVENT}=="1", ACTION=="add", SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="0009",  RUN+="/sbin/fxload -v -t fx2  -I /etc/hotplug/usb/xusbdfwu.fw/xusbdfwu.hex -D $env{DEVNAME}"
ENV{UDEVD_EVENT}=="1", ACTION=="add", SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="000b",  RUN+="/sbin/fxload -v -t fx2  -I /etc/hotplug/usb/xusbdfwu.fw/xusbdfwu.hex -D $env{DEVNAME}"
ENV{UDEVD_EVENT}=="1", ACTION=="add", SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="000d",  RUN+="/sbin/fxload -v -t fx2  -I /etc/hotplug/usb/xusbdfwu.fw/xusbdfwu.hex -D $env{DEVNAME}"
ENV{UDEVD_EVENT}=="1", ACTION=="add", SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="000f",  RUN+="/sbin/fxload -v -t fx2  -I /etc/hotplug/usb/xusbdfwu.fw/xusbdfwu.hex -D $env{DEVNAME}"

ACTION=="add", DEVPATH=="/module/windrvr6", RUN+="/bin/rm -f /dev/windrvr6"
ACTION=="add", DEVPATH=="/module/windrvr6", PROGRAM="/bin/grep windrvr6 /proc/devices" RUN+="/bin/mknod -m 0666 /dev/windrvr6 c %c{1} 0"
ACTION=="remove", DEVPATH=="/module/windrvr6", RUN+="/bin/rm -f /dev/windrvr6"

ACTION=="add", DEVPATH=="/module/xpc4drvr", RUN+="/bin/rm -f /dev/xpc4_?"
ACTION=="add", DEVPATH=="/module/xpc4drvr", PROGRAM="/bin/grep xpc4drvr /proc/devices" RUN+="/bin/mknod -m 0666 /dev/xpc4_0 c %c{1} 0"
ACTION=="add", DEVPATH=="/module/xpc4drvr", PROGRAM="/bin/grep xpc4drvr /proc/devices" RUN+="/bin/mknod -m 0666 /dev/xpc4_1 c %c{1} 1"
ACTION=="add", DEVPATH=="/module/xpc4drvr", PROGRAM="/bin/grep xpc4drvr /proc/devices" RUN+="/bin/mknod -m 0666 /dev/xpc4_2 c %c{1} 2"
ACTION=="add", DEVPATH=="/module/xpc4drvr", PROGRAM="/bin/grep xpc4drvr /proc/devices" RUN+="/bin/mknod -m 0666 /dev/xpc4_3 c %c{1} 3"
ACTION=="remove", DEVPATH=="/module/xpc4drvr", RUN+="/bin/rm -f /dev/xpc4_?"

Xup: GPL programmer for Spartan 3e Starter Kit

There is an GPL alternative to Xilinx's iMPACT called Xup. Xup can be used to program the Spartan 3e Starter kit. The primary documentation and download are at .

In its current form Xup can be immediately used to program the starter kit development board on 32bit Gentoo systems through the USB cable supplied with the Xilinx board. Note:AMD64 users need to replace all instances of "long int" to "u_int32_t" in the source files under Xup's provided XC3Sprog. Send any questions regarding this to mailto://

The author of Xup mentions that his software might be usable for programming Virtex devices provided that modifications are made.

Xup works by re-programming the 8051 microprocessor in the Cypress USB slave chip on the Spartan3E board. This permits the 8051 to implement a message layer on the USB that can be understood by the customized XC3Sprog application that is provided with Xup. This protocol replaces the undocumented protocol used by the Xilinx drivers. The new 8051 source code is provided with Xup, so it may be possible to eventually create a USB data path from your PC to your FPGA application by reprogramming the 8051 and the CPLD.

Installing Xup on Gentoo generally follows this pattern:

su #must be root to emerge, install, and change the config files
emerge libusb   #uses the generic user-space USB library
emerge fxload   #generic jtag downloader
emerge sdcc     #tools to compile the 8051 code
cd ~/root_download_dir    #(or wherever you usually build non-gentoo stuff)
tar zxvf xup-0.0.2.tar.gz
cd xup-0.0.2
./p -v 4 prog.xsvf # download xup's pre-built programmer CPLD image
                   # this will take 5-30 minutes
                   # you only need to do this when installing/upgrading xup,
                   # or switching between iMPACT and xup
cd XC3SProg # now build xup's XC3SProg
./xc3sprog /some/file.bit
cp -a xc3sprog /usr/local/bin #make available to the general user.

In order to use it for non root user, you should create a special group (here xilinx) and add the authorized users to this group. Then create a simple udev script (as for instance /etc/udev/rules.d/z25-xilinx.rules):

ACTION!="add", GOTO="xilinx_rules_end"
SUBSYSTEM!="usb_device", GOTO="xilinx_rules_end"

# xilinx xup cable
SYSFS{idVendor}=="03fd", SYSFS{idProduct}=="000d", MODE="664", GROUP="xilinx"


The provided xc3sprog uses a file named devlist.txt which has JTAG IDCODES in it. Some starter kit boards have two devices with variant codes that are not in the file provided with Xup. Adde the following lines to devlist.txt:

      41c22093  8 XC3S500E
      f5045093  8  XCF04S

These differ in the first digit from exisitng codes for these devices. After this, the program should run.

User-Space Cable Driver library

This library is misnamed "usb-driver" because it was initially developed for USB cables. It now permits IMPACT and other Xilinx tools to drive most common USB and parallel cables, including some that IMPACT cannot drive using the normal kernel-driver approach. The main web site is here.

Installation on Gentoo generally follows this pattern:

su            # root must emerge, install and change the config files.
emerge libusb #install the generic user-mode usb library
emerge fxload #install the generic USB firmware loader
mkdir <your_download_path>
cd <your_download_path>
tar xzvf usb-driver*
cd usb-driver
more README # read this. It has better instructions for the steps after the make
mkdir /opt/usb-driver  #or other directory of your choice
mv *.so /opt/usb-driver
nano /usr/local/bin/startise #edit the ISE startup script to preload usb-driver

add the following line immediately above the "exec ise" line:

export LD_PRELOAD=/opt/usb-driver/

and save and exit the file.

Now, carefully follow the rest of the instructions for your cable type in the README. For USB, pay special attention to the fxload instructions. For parallel rembember to build your kernel with


integrated or as modules (in that case load them before starting Xilinx)

This thread on comp.arch.fpga has the initial announcement, two good sets of step-by-step instructions, and many reports of success.

Troubleshooting and bugs

Known / Suspected Bugs

Cable is locked

IMPACT can crash under various conditions and leave the cable in a "locked" condition. For example, if an Impact profile uses an .mcs file, then changing .mcs prom file when Impact window is open causes Impact to crash. This can lock whichever cable the IMPACT was using when the crash occurred.

The solution to this problem is to run IMPACT in batch mode, to clear the lock. From any commandline window, run the following:

impact -batch
setmode -bs
setcable -p auto

ISE fails to launch some applications

Some examples:

These are all symptoms that your system's installed tcl or glibc are too new or you're missing openmotif. You must follow the instruction in the "Prerequisites" section above.

QT and fonts related problems

But those two problems above won't give you real problem when you run Xilinx, but this is nice to see a clear environment.

Trouble shooting the ds300 and XUP-V2P usb-interface

Not all of these steps are needed:

Current work around for XUP boards if you are still experiencing problems:
1. Turn on XUP board.
2. Plug in to USB
3. Wait 10 seconds
4. Unplug and reconnect USB


EDK Simulation Libraries Compilation

EDK uses xilperl to compile simulation libraries. xilperl requires, without it, you'll get this error:

xilperl: error while loading shared libraries: cannot open shared object file: No such file or directory

A quick fix is to create a symbolic link:

cd /usr/lib
ln -s

Note: If you are using amd64, you'll want to create the link in /usr/lib32

Retrieved from ""

Last modified: Sat, 11 Oct 2008 05:56:00 +0000 Hits: 28,745