Embedded Linux

Introduction

FPGAs are best known for their flexibility and versatility. Such flexibility allows FPGAs not only to be used for custom logic circuits but also implement a processor on it and even run Linux (or other operating system) on the processor. The possibilities are only limited by imagination, and also by FPGA speed grade and size. This article will discuss how to create/implement Microblaze processor and run Linux on Galatea PCI Express Spartan6 FPGA Module. This is based on our previous article series for Saturn Spartan 6 FPGA Module. So we highly recommend that you read the series for Saturn and get yourself familiar with the steps. So let’s dive right in.

Structure

This article is structured into 4 sections.

• Section I:Creating the Microblaze based design for Galatea
• Section II:Generating Device Tree
• Section III:Building Linux Image
• Section IV:Running Linux on Galatea

Prerequisites:

For following this article, you would require:

• Hardware
  • Galatea PCI Express Spartan6 FPGA Module
  • Xilinx Platform Cable JTAG debugger
• Software:
  • Xilinx Platform Studio installed on either Windows or Linux system
  • Linux system (author used Ubuntu 14.04 64-bit)

Section I: Creating the Microblaze based design for Galatea

For this section we are building Microblaze based embedded platform for Linux using Xilinx EDK. Now let’s get started. We will need to use XPS Base System Builder (BSB) to create a new project. To make the process easier, download BSB Wizard files from here and copy to the folder “C:\Xilinx\xx.xx\ISE_DS\EDK\board”. Once extracted, the complete path to the file should look like C:\Xilinx\xx.xx\ISE_DS\EDK\board\NumatoLab\ipxact\GalateaPCIeDevBoardLX45T_V1\data”. Now go to All Programs > Xilinx Design Tools > EDK and start Xilinx Platform Studio. Once XPS is loaded, click on “New BSB Project” under File menu or press Ctrl + Shift + B to invoke the BSB wizard. If everything went fine, you should be presented with BSB wizard window as shown below.

Enter path to a folder where you want to store the project and a project name (Here the project name is Galatea_Linux in the image above). Select AXI System in the interconnect Type section and click OK. In the next page of the wizard, select “Numato Lab” from the Board Vendor combo box (This option should be available if you have placed the BSB wizard support files for Galatea properly as mentioned earlier). Select GalateaPCIeDevBoardLX45T and 1.0 from Board Name and Board version combo boxes respectively and click “Next” to go to the next page:

Leave the Optimization Strategy to its default value and click Next.

By default, FT232_UARTand DDR3_MCB_BANK3 will be selected. Select memory size, I-cache size and D-cache size as 16KB. Then select FT232_UART peripheral and set the baud rate to 115200 and check the “Use Interrupt” check box. Then select “axi_timer” in the “Available Peripherals” list and add that to the system. Select the timer and check the “Use Interrupt” check box. Make sure everything is setup as shown in the image below and click “Finish” button.

Now Xilinx Platform Studio will generate a project for you based on the selections you made in the BSB wizard. If everything went well, you will be presented with a window as shown below

There is a bug in XPS where it fails to load valid parameters for DDR3_MCB_BANK3 from BSB Wizard files. This will result in failure in generating netlist. Workaround for this bug is to just regenerate the files for this IP core. Its not a difficult task. Just double click the “DDR3_MCB_BANK3” IP and click “Next” at every step and finally click “Finish”. There is no need to modify anything, just leave everything as is and click “Finish”.

Add “axi_spi” IP from IP Catalog. Right click on axi_spi_0 in the “System Assembly View > Bus Interfaces” tab and select “Configure IP” from the pop up menu. The AXI SPI Configuration Wizard will open. Set “Include both Receiver and Transmitter FIFOs” as “FALSE” and “Ratio of AXI Clock Frequency To SCK Frequency” as 2 and click “OK”.

Now we will configure the peripheral IPs. Right click on microblaze_0 in the “System Assembly View > Bus Interfaces” tab and select “Configure IP” from the pop up menu. The Microblaze Configuration Wizard will pop up. Select “Linux with MMU” under the “Select Configuration” options (Please see image below). 

At this point, we have finished configuring Microblaze CPU and all peripherals. The next step is to route all peripheral interrupts to the microblaze CPU through the interrupt controller. To configure interrupts, go to the “Ports” tab in “System Assembly View” and locate the “Open interrupt Control Dialog” button. This button is a little tricky to locate. Please see the image below for help.

In the interrupt control dialog box, make sure that both  FT232_UART and axi_timer_0 are connected to the interrupt controller and debug_module and axi_spi_0 are not connected to the interrupt controller as shown in the image below.

Now go to the “System Assembly View” and select “Addresses” tab and make sure all peripherals have a base address assigned (XPS will take care of this automatically, but just in case). Note the base address of DDR3 memory, we will need it when building Linux kernel. At this point, we are ready to build the project. Click on the “generate bitstream” button the left side pane to start build process. If build fails due to timing closure issues, go to project menu in XPS, select Project Options and uncheck “Treat timing failures as errors”. This should help the build complete without errors.

Now we recommend that you create a SDK application project for this hardware platform and test its basic functionality by creating a “Hello world” application. Please follow the steps similar to the section “Creating Application program for Microblaze based Embedded Platform” in the article Creating Xilinx EDK test project for Saturn – Your first Microblaze processor based embedded design to create a SDK project(creating SDK project for Galatea is similar to creating a SDK project for Saturn). Choose “Hello world” SDK application template when generating the application. Run the application on the board to make sure that everything so far works as expected.

Assuming you were able to build the hardware platform using XPS and test it using SDK successfully, let us move on to the discussion about how to build Linux kernel. There are different ways to do this depending on how much time and effort you would like to invest. The easiest of all is to use a tool such as Buildroot. In this example, we will use Buildroot to build our kernel. Buildroot, when properly configured, can download Linux kernel source, build cross compilation tools and build the kernel itself all with a single command.

Please note that we will continue using Windows for running Xilinx tools (and of course Linux for building kernel). Author has used Ubuntu 14.04 LTS 64 bit desktop version while putting together this article. We will do the following steps one by one to build the Linux Kernel.

Section II: Generating Device Tree

On many platforms, Linux kernel depends on a data structure called Device Tree to discover and configure different hardware components available on the board. Kernel uses the device tree in binary format which is generated by using device tree compiler. The input to the device tree compiler is a text file (with extension .dts) that describes all the hardware and dependencies. This file can be edited manually by hand if necessary. But fortunately, there are tools available that can help us generate device tree from our XPS/SDK projects.

Having completed all the steps before, now download the device-tree repository from Xilinx’s github account: https://github.com/Xilinx/device-tree-xlnx.git . If you have downloaded the zip, extract it in the same location as your SDK workspace. In case of the author, the directory structure was D:\XPS_PROJECTS\GALATEA_DEVP_BOARD\Galatea_Linux\SDK\device-tree-xlnx-master

Step 1: In XPS, select Project -> Export Hardware Design to SDK -> Export & Launch SDK. This opens the Xilinx SDK

Step 2: In SDK, go to Xilinx Tools -> Repositories.

Step 3: In the Dialog window, we have a section named “Local Repositories”.  Select “New” and select the device tree folder which you had downloaded and extracted to SDK workspace. Final result should look like in the below image.

Step 4: Go to File -> New -> Board Support Package. In the Dialog window, select “device_tree” under “Board Support Package OS” and press “Finish” and then “OK” in another dialog that opens.

This should generate a system.dts file along with a .dtsi file. We need both of them

Step 5: We have to merge the ‘.dtsi’ and ‘.dts’ files. So open both of them in some text editor (Notepad++ etc) and copy the contents of system.dts and paste them in the .dtsi file just after the line ” model = “Xilinx MicroBlaze” .  Don’t forget to add “/dts-v1/;” at the top of .dtsi file also. The final content should look like this

At this point, we will need to make some changes to the dts file manually. Open galatealx45t.dts in your favorite text editor and replace the bootargs = “” line with the following

"console=ttyUL0,115200";
linux,stdout-path = &ft232_uart;
stdout-path = &ft232_uart;

Now, save this modified file as “galatealx45t.dts”. And copy “galatealx45t.dts” file to your Linux System.

Section III: Building Linux Image

Step 1: Login to your Linux workstation to download and setup buildroot. On a Ubuntu 14.04 desktop clean installation you will need to install a few packages to make Buildroot work. Run the following command to install those.

cmd> sudo apt-get install build-essential bison flex gettext libncurses5-dev texinfo autoconf automake libtool

You may need to install Qt lib if you prefer to use xconfig instead of menuconfig while configuring Buildroot (please note that we will not use xconfig or menuconfig in the article rather load a default configuration that is known to be working).

Step 2: Now create a convenient folder on your Linux machine and move to that folder on the command line.The author created “Galatea_Linux” directory inside the “home” directory.  Download buildroot to that folder. You can download buildroot manually from Buildroot download page or by running the following command.

cmd> wget http://buildroot.uclibc.org/downloads/buildroot-2015.11.tar.gz

You can use latest buildroot release instead of the above. Now, extract the downloaded tarball archive using following command:

cmd> tar -xvf buildroot-2015.11.tar.gz

All files should be extracted to the folder “buildroot-2015.11”.

cmd> make numato_galatea_defconfig

cmd> make

cmd> c:\Xilinx\14.7\ISE_DS\settings64.bat
cmd> xmd

cmd> connect mb mdm

dow simpleImage.galatealx45t

cmd>con 0xc0000000