DIY

Setting up a T2080RDB for desktop use

This article is meant to guide you in setting up the developer board NXP T2080RDB for using it as a desktop personal computer. We decided to work on this platform because it allowed us to test the CPU we selected for our project aiming at a modern and fully open hardware motherboard based on the PowerPC architecture.

Index


T2080 Development Board overview

Before attempting to do anything with your T2080RDB development board, it is highly advisable to familiarize yourself with it. Below an image of the devkit interior.

NXP T2080RDB motherboard

You may start by reading these freely available documents provided by NXP:

Below is an image of the T2080RDB-PC architecture extracted from the above mentioned documents.

block diagrams of the T2080RDB architecture

It is also advisable you have prior technical knowledge of the Linux kernel works and how *nix like OSes work in general, as this will GREATLY help you when setting up your T2080RDB board to run Linux.

What characterizes the board the most is its CPU which is the NXP T2080, e6500 64-bit Power Architecture with Altivec technology, 4 x e6500 dual-threaded cores, low-latency backside 2MB L2 cache, 16GFLOPS x core.

Another interesting source of information about the board is the README file contained in the U-Boot code repositories on GitHub, here is the one maintained by the group developing QEMU https://github.com/qemu/u-boot/tree/master/board/freescale/t208xrdb
Should you have further doubts or questions, you may have a look at the official NXP forum dedicated to their QorIQ T2 Devices
https://community.nxp.com/community/qoriq/t-series/content?filterID=contentstatus%5Bpublished%5D~category%5Bqoriq-t2-devices%5D

The Power Progress Community and it’s members CAN NOT be held responsible for any potential damage done to your T2080 RDB that renders it inoperable due to lack of knowledge and/or incompetence of the end-user. IF you know what you’re doing, then the process of setting up the T2080 development board up should go well for you, with little difficulty.

Also please note, the Google Docs version of this guide is under continuous editorial by members of the Power Progress Community, so sections of it are likely to get updated or moved, as time goes on. If any mistakes have been made in this guide, please let us know about them, and we will update them accordingly, in the next revision of this guide. To do so, you may make suggestions directly on the Google Docs version of this document, we will take care of updating the blog post accordingly.


The T2080 CPU and the C293 crypto coprocessor

The NXP T2080 processor has the following characteristics:

  • Four dual-threaded e6500 cores built on Power Architecture technology, Up to 1.8 GHz each, 6.0 DMIPS/MHz per core, shares a 2 MB L2 cache
  • Three levels of instructions: User, supervisor, hypervisor
  • Hybrid 32-bit mode to support legacy software and transition to a 64-bit architecture
  • Advanced power management saving modes include state retention during power gating
  • 64-bit DDR3/3L SDRAM memory controller with ECC support, up to 2.1 GT/s, memory pre-fetch engine
  • Two PCI Express 3.0 controllers
  • Two PCI Express 2.0 controllers
  • Two Serial ATA (SATA) 2.0 controllers
  • Two high-speed USB 2.0 controllers with integrated PHYs
  • Enhanced secure digital host controller (SD/MMC/eMMC)
  • Enhanced serial peripheral interface (eSPI)
  • Four I²C controllers
  • Four UARTS
  • Integrated flash controller supporting NAND and NOR flash memory
  • CoreNet platform cache
  • SerDes 8 lanes at up to 10GHz
  • SerDes 8 lanes at up to 8GHz
  • Endpoint SR-IOV
  • Two Serial RapidIO 2.1 controllers/ports running at up to 5 GHz with Type 11 messaging and Type 9 data streaming support
  • DPAA incorporating acceleration for the following functions
  • Packet parsing, classification and distribution up to 24Gb/s (FMAN)
  • Queue management for scheduling, packet sequencing and congestion management of up to 2^24 queues (QMAN)
  • Hardware buffer management for buffer allocation and de-allocation with 64 buffer pools (BMAN)
  • Integrated security acceleration (SEC) to 10 Gbps
  • Decompression/compression acceleration at up to 17.5 Gbps (DCE)
  • Signature detection (PME) to 10Gb/s
  • DPAA support of RapidIO messaging (RMAN)

On the NXP website you may access more information about the CPU. Below a block diagram of the chip.

If you are interested in more in-depth information about the Power Architecture e6500 you may want to have a look at the e6500 Core Reference Manual (E6500RM, Rev 0, 06/2014)

The board comes with the C293 crypto coprocessor which is aimed at offloading the generation of complex public keys (typically 2048-bit) and it is meant for data centres and network secutirty appliances. These are its characteristics:

  • CPU PowerPC 32bit e500-v2 1.2GHZ, 32KB I and D caches, 512 KB L2 cache, Hardware cache coherency
  • 512KB platform SRAM
  • One PCIe Gen 2.0 controller x1, x2, x4
  • DDR3/3L controller with ECC, max 4GB of memory
  • Two enhanced three speed ethernet controller (eTSEC) supporting 10/100/1000Mbps
  • Supports RGMII/RMII interfaces
  • SPI controller used for booting with internal ROM, supporting Atmel Rapid-S and Winbond dual read interface
  • Dual I2C controllers
  • Two UARTs
  • 64-bit GPIO
  • Supports secure boot
  • SEC 400MHz
  • DDR 1.2GHz
  • 2048b RSA Private Key 32,907
  • Bulk Encryption (AES-HMAC-SHA-1 for SSL or Ipsec) 12 Gbps

Below the C923 logical block diagram.

You may find more more information about the C293 coprocessor on the NXP website.


DIP switches configuration

The T2080 dev board uses a bank of three DIP switches to configure the basic settings of the hardware, much like with the manual jumpers and DIP switches of an AT PC motherboard. These need to be set to specific positions in order to make the board boot any firmware from an SD card, instead of using it’s onboard flash memory, which it is configured to do so by default when it leaves the factory.

Before doing anything with these switches, please make sure you make a note of the current position of each switch, so you may set them back to their previous positions if you wish to restore your T2080 dev board back to it’s previous or default condition.

Below is an accompanying picture and table of what positions the switches need to set to:

T2080RDB dip switches
T2080RDB dip switches configuration for booting from the SD card

The above is the DIP switch configuration required for booting from the SD card.

The DIP switches configuration below was the original, should you need to set them back again.

T2080RDB manifacturer default dip switches configuration

Serial debug using the UART connection

As our current custom build of the U-Boot firmware for the T2080 dev board can not initialize any graphics card at boot time you will not be able to see what happens at boot time from the monitor attached to the graphics card. The only way to get live feedback when you switch on the board as well as the only way to access the U-Boot console is by connection to the T2080 dev board via a serial cable.

To do this, You will need a computer with a serial COM port or a USB UART device and a terminal emulator program running on the computer you intend to connect the T2080 dev board to.
For terminal emulator programs, I use GtkTerm on Linux, a number of popular Linux distros have a package for it on their package servers. Though if you are using Windows, PuTTY or TeraTerm are also options. Though TeraTerm is also particularly a good choice, as it has a number of more in depth configurable options, should you need them.
The T2080 dev system also ships with a 9 pin DB port to 3 pin header cable in the box, You’ll need this to connect to the COM port or USB UART with a COM port, on the machine you’re running the terminal emulator program on.

Connecting the Serial port to the T2080s UART port.

T2080RDB case front
  1. Attach the RS-232 cable or USB UART device between the machine you intend to run the terminal emulator on, to UART0 port (Rx-GND-Tx 3 pins), on the front of the T2080 dev board (If you are using the COM port to three pin header cable that comes with the T2080, then the red cable goes on top). If you are using a USB UART device with bare jumper connectors. Then you will have to route TX from the USB UART to RX on the T2080s UART 0 port, and TX from UART0 to RX on the USB UART device, connecting GND to GND straight through on either of the connectors.
  2. Configure the terminal program you’re using to: 115200 baud, 8 data bits, No Parity, 1 stop bit and flow control to hardware/none. If the right COM port has been selected, usually TTY# (or usbTTY#, if your using a USB UART) under Linux or COM# under Windows, then if everything has been set up and configured properly, you should start getting text feedback from the U-Boot firmware, if it has been successfully loaded from the SD card. Once Linux has booted, you will also be able to get live feedback of errors and other issues from the Linux kernel. You can also bring up a login prompt and have a text console through serial by tapping either SPACE or RETURN etc. This can be very handy for running monitoring programs or trying to troubleshoot certain issues, such as, if the graphics hardware hasn’t been initialized by the window manager etc.

Attaching a PCI-E video card

The T2080 dev board only has one PCI-E 4x slot at an odd angle, that is quite a limiting factor for anything you plan to do with the card.
Connecting a graphics card to it will require a PCI-E riser cable/adapter of some kind, as seen in the picture below as an example.
You may want to try the following cable, as it seems to be of a much higher quality than the others we have tried so far. It was found on Amazon (https://www.amazon.com/gp/product/B07QRP65M1/).

PCIE x4 cable extender

In our experience, purchasing a low quality cable may lead to problems in the communication in the PCIe channel that may impact the correct GPU operations, so it is highly recommended you purchase a good quality PCI-E 4x to 16x riser cable adapter.

You may spot if there are any PCI-E connectivity issues by checking the kernel log via the serial console.
If the graphics card is very power hungry, the power provided by the PCI-E power connector might not be enough. Most modern graphic cards of this type have their own PCI-E power connector, either with 6 pins or with 8 pins. It may occur that the card is power hungry, does not have its own PCI-E power connector, and the T2080 board does not provide enough power via its PCI-E connector. In this case, you should try buying a cable with a power connector of its own, such as the one shown in the picture below, which however demonstrated being of low quality and caused the kernel log error a flood of error messages on the PCI-E connection.

PCIE x4 to x17 cable adapter

If you want a graphics card that will work mostly “trouble-free” with the T2080 dev board, then it is best to aim for one that uses a GPU from AMD’S Terrascale Mk 1-3 architecture, as these work the best with Mesa3D for graphics acceleration.

While Mesa3D does have preliminary support for GPU’S based on their GCN mk1-2 architecture, it is not complete and has issues.
See Wikipedia’s list of AMD GPU’s here for use as a guide in choosing a graphics card: https://en.wikipedia.org/wiki/List_of_AMD_graphics_processing_units
Other people have reported the Radeon HD 4550, 5450, 5550 and 6670 cards as working as well.


Setup of the micro SD card with firmware and kernel

In order for the T2080 SOC to boot off of a micro SD card, it needs some misc firmware for features of the T2080 SOC, the U-Boot firmware and the Linux kernel writing to the SD card you wish to use. The U-Boot firmware initializes or “bootstraps” the system, and prepares it for handing off to the OS, which in this case is Linux.

The instructions below you guide you on how to do this.

First you need a micro SD card, it will be completely wiped out, so be sure not to delete important data. In theory a size of at least 4 GB should work, but so far we tested 8 GB, 16 GB and 32 GB modules.

A useful advice when writing to an SD card is to be sure that the system has finished writing data into the SD card, and no data is left in the filesystem caching mechanism. To do so, just enter in the Linux terminal the command “sudo sync”, here a link to its manual pages. As you will see, sometimes writing to the SD card takes quite some time, be patient and leave it finishing up.

CAREFUL: This will DESTROY all data currently on the SD card you wish to use!

Using a PC with Linux

  1. Insert your SD card in your card reader attached to a PC with Linux.
  2. Using gparted (Debian/Ubuntu users: if not present you may install it entering “sudo apt install gparted”)
    a. Select the SD card from the list of available disk devices and keep trace of the device name (in our case was “/dev/sdc”)
    b. Create a new msdos partition table for the SD card
    c. Create one primary “ext2” partition leaving 1GB of empty space BEFORE the primary partition and mark such as “ext2” partition as bootable.
    Specifying an ext2 filesystem is important, otherwise U-Boot might not be able to read its content.
    d. Apply all changes to the disk
    e. Close gparted
  3. Download the U-Boot binary file from
    https://gitlab.com/oshw-powerpc-notebook/T2080customizations/blob/master/u-boot/u-boot-sdcard.bin
  4. Download the DTB file from
    https://gitlab.com/oshw-powerpc-notebook/T2080customizations/blob/master/device_tree/uImage.dtb
  5. Download the FMAN microcode from
    https://gitlab.com/oshw-powerpc-notebook/T2080customizations/blob/master/fman_microcode/fsl_fman_ucode_t2080_r1.1_106_4_18.bin
  6. Download the Cortina CS4315/CS4340 10G PHY microcode from
    https://github.com/NXP/qoriq-firmware-cortina/blob/integration/cs4315-cs4340-PHY-ucode.txt
  7. Write the U-Boot file “u-boot-sdcard.bin” to the SD card using the “dd” command
    (careful, you must enter the device name of your SD card! Mine was “/dev/sdc”, but yours might be different!)
    sudo dd if=u-boot-sdcard.bin of=/dev/sdc seek=8 count=2048
  8. Write the FMAN microcode/firmware “fsl_fman_ucode_t2080_r1.1_106_4_18.bin” to the SD card using the “dd” command
    (careful, you must enter the device name of your SD card! Mine was “/dev/sdc”, but yours might be different!)
    sudo dd if=fsl_fman_ucode_t2080_r1.1_106_4_18.bin of=/dev/sdc seek=2080 count=128
  9. Write the Cortina CS4315/CS4340 microcode/firmware “cs4315-cs4340-PHY-ucode.txt” to the SD card using the “dd” command
    (careful, you must enter the device name of your SD card! Mine was “/dev/sdc”, but yours might be different!)
    sudo dd if=./cs4315-cs4340-PHY-ucode.txt of=/dev/sdc seek=2208 count=512
  10. Mount the “ext2” primary partition created in the SD card
  11. Create a “/boot” folder in the mounted “ext2” partition of your SD card
  12. Download the latest 64bit kernel kernel from http://repo.powerprogress.org/t2080rdb/kernel_5.6.15.tar.gz
  13. Extract the content of the file “kernel_5.6.15.tar.gz” using a GUI tool of your preference or entering “tar -xvzf kernel_5.6.15tar.gz” in a terminal
  14. From the folder where you extracted the kernel
    Copy the kernel file named “uImage” to the “/boot” folder of the SD card
    Copy the DTB file “uImage.dtb” to the “/boot” folder of the SD card
    Copy the “System.map” to the “/boot” folder of the SD card
  15. Before unmounting the micro SD card, be sure that all data has finished transferring to the card. Do that by entering the command “sudo sync”
  16. Insert the micro SD card in the slot on the T2080RDB
T2080RDB micro SD card slot

More information about the PPC64 kernel

If you want more information on the PPC64 kernel we provide, you may have a look in our GitLab public repository.
In addition to the configuration that you may find also in the tar.gz kernel file above, we provide instructions on how to modify its configuration, and how to compile a kernel.
https://gitlab.com/power-progress-community/oshw-powerpc-notebook/T2080customizations/tree/master/kernel/5.6.15


Setup of the SATA storage with a Linux distribution

Fienix, a 32bit PowerPC Linux distro

“Fienix” is a good PowerPC mixed 32 (user space) and 64 bit (the kernel) Linux distro released by Casey Cullen, here its homepage https://fienixppc.blogspot.com/

Download the disk image from https://fienixppc.blogspot.com/p/instructions-for-u-boot.html

Using the partitioning tool called “gparted”, create an “ext4” partition labeled “FIENIX” on your HDD or SDD and create a Linux Swap partition as well at the end of the disk, 1GB or 2GB would do for the swap. Keep trace of the device name as you will use that.

As a root user (using “sudo” in Ubuntu or “su” in Debian), enter:

dd if=/path/to/Fienix.img of=/dev/yourdrivepartition

where “/dev/yourdrivepartition” is the path to the FIENIX partition you created, such as “/dev/sdb1”

Adjusting and correcting the partition size

  • Open gparted
  • Select the FIENIX partition
  • Right click and select Resize/Move, then resize the partition to the near maximum capacity of the drive (if you wish) at least leaving 8 to 10 GiB free for a SWAP partition. You can set the amount of free space after the partition by entering a value in the “Free space following” box.
  • Right click on the unallocated space and select New from the menu, From the File System menu, select Linux Swap and set it to fill the remainder of the unallocated space of the drive.
  • Click on the Edit menu, Then select Apply All Operations from the menu.

Now mount the partition with FIENIX and copy the kernel modules:

  • Copy the kernel modules in “/lib/modules/” (the folder is in the kernel package) to the /lib/modules/ directory on the partition that contains Fienix.

Debian SID, a PowerPC 64bit Linux distro

We have a pre-configured disk image with Debian SID PPC64 which can be downloaded from here:

http://repo.powerprogress.org/t2080rdb/hdd_debian_sid_ppc64_kernel_5.6.15.tar.gz

The system comes with the LXDE desktop environment, and a series of useful software pre-installed, such as Libre Office, Inkscape, GIMP, Neverball, and the Synaptic Package Manager for installing additional software. As a result the final image is quite big, 7.2 GB compressed, 20 GB uncompressed, so you will need a SATA disk (either a traditional HDD or an SSD) with at least 20GB, more is advised for enabling the Linux swap partition.

  1. Prepare the destination HDD using gparted (or a similar disk utility) and keep trace of the device and partitions names
    a. Create a new partition table “ms-dos”
    b. Create a first partition formatted as “ext4” with at least 20GB and leave 4GB of free disk space after such partition (keep track of the partition numbers as it will be later used to write the hdd image)
    c. Create a second partition as “linux-swap” of 4GB at the end of the disk.
  2. Copy the provided hdd image on the disk
    a. You may uncompress the hdd tar.gz and write it directly to the disk in one go with the following command:
    tar xvzf hdd_debian_sid_ppc64.tar.gz | sudo dd of=/dev/yourdrivepartition bs=4M
    (e.g. on my system was “tar xvzf hdd_debian_sid_ppc64.tar.gz | sudo dd of=/dev/sdb1 bs=4M”)
    b. Or alternatively you may first uncompress the image, and then write it to the disk
    tar xvzf hdd_debian_sid_ppc64.tar.gz
    sudo dd if=hdd_debian_sid_ppc64.img of=/dev/yourdrivepartition bs=4M
  3. Resize and fix the partition content using gparted
    a. Click the Partition menu, then click Check and Apply to perform the automatic fix

The default user is “ppc64” and its password is “ppc64”. The password for the “root” user is “ppc64”.

In case you want to change the current keyboard layout, open a terminal and enter “export PATH=$PATH:/usr/sbin” and then enter “sudo dpkg-reconfigure keyboard-configuration”.

After logging in, you may want to change your password, as the default one is quite insecure.

Attaching the SATA storage device

Attach the SATA storage device, to the bottom SATA port, of the pair of onboard SATA ports, of the T2080 dev board. This port is the primary SATA drive, and will appear as the primary SDA drive under Linux, while a second SATA drive on the secondary SATA port will appear as drive SDB.

T2080RDB primary SATA port

Setup of U-Boot for booting Linux

Before changing any variable in your U-Boot configuration, you should backup your current settings.
To backup your settings, use the command “printenv” to list all current settings in your terminal emulator program and then copy and paste the resulting settings from the serial terminal program to a text file. In this way if anything goes wrong you will be able to revert a setting back to its original value.
As each environment variable stored in U-Boot cannot be too long, we have to store the required information in various variables, then include these variables in a comprehensive call.
These are the following minimum commands that need to be entered in the U-Boot prompt, in order to boot linux:

  1. setenv consoledev ttyS0
  2. saveenv
  3. setenv baudrate 115200
  4. saveenv
  5. setenv loadaddr 0x3000000
  6. saveenv
  7. setenv fdtaddr 0x05000000
  8. saveenv
  9. setenv bootfile uImage
  10. saveenv
  11. setenv fdtfile uImage.dtb
  12. saveenv
  13. setenv bootcmd ‘setenv bootargs root=/dev/sda1 rw rootdelay=5 console=$consoledev,$baudrate;mmcinfo;ext2load mmc 0:1 $loadaddr /boot/$bootfile;ext2load mmc 0:1 $fdtaddr /boot/$fdtfile;bootm $loadaddr – $fdtaddr’
  14. saveenv

Type “printenv” in U-Boot prompt and check if the stored variables match the ones you have just entered. If they do then type “reset” and your T2080 dev board should restart to boot the Linux kernel off the SD card and will proceed loading the Linux distro you have in the first partition (/dev/sda1), off of the connected SATA storage device.

You may also want to change the “root=/dev/sda1” value in the bootcmd string to match the root partition number containing the Linux distribution of your choice, if it is not on a primary partition. As having the root file system on a second partition on the drive, would make the value “root=/dev/sda2” etc.

As a reference, the following page is a dump of all the variables in my T2080 dev boards U-Boot config.
I will also include a page of u-boot commands in the Notes and Issues section, Which is located further down this guide

bootcmd=setenv bootargs root=/dev/sda1 rw rootdelay=5 console=$consoledev,$baudrate;mmcinfo;ext2load mmc 0:1 $loadaddr /boot/$bootfile;ext2load mmc 0:1 $fdtaddr /boot/$fdtfile;bootm $loadaddr - $fdtaddr
bootargs=root=/dev/sda1 rw rootdelay=5 console=ttyS0,115200
bdev=sda1
baudrate=115200
bootdelay=10
bootfile=uImage
consoledev=ttyS0
eth0addr=AF:F5:59:14:09:DE
eth1addr=D7:C8:74:00:61:24
eth2addr=C2:B0:72:06:58:8A
eth3addr=A2:BF:1C:7A:80:E0
eth4addr=05:BC:26:F4:B3:65
eth5addr=F4:84:06:81:03:54
eth6addr=B4:6E:ED:11:F0:4B
ethact=FM1@DTSEC3
ethaddr=AF:F5:59:14:09:DE
ethprime=FM1@DTSEC3
fdtaddr=0x05000000
fdtfile=uImage.dtb
fec_addr=AF:F5:59:14:09:DE
fileaddr=4000000
filesize=8ec1
fman_ucode=7fb28dc8
gatewayip=192.168.1.1
hwconfig=fsl_ddr:ctlr_intlv=cacheline,bank_intlv=auto;usb1:dr_mode=host,phy_type=utmi
initrd_high=0xffffffff
ipaddr=192.168.1.111
loadaddr=0x3000000
mem=3500Mvideo-mode="fslfb:1024x768-32@60,monitor=vga"
netdev=eth0
nfsboot=setenv bootargs root=/dev/nfs rw nfsroot=$serverip:$rootpath ip=$ipaddr:$serverip:$gatewayip:$netmask:$hostname:$netdev:off console=$consoledev,$baudrate $othbootargs;tftp $loadaddr $bootfile;tftp $fdtaddr $fdtfile;bootm $loadaddr - $fdtaddr
ramboot=setenv bootargs root=/dev/ram rw console=$consoledev,$baudrate $othbootargs;tftp $ramdiskaddr $ramdiskfile;tftp $loadaddr $bootfile;tftp $fdtaddr $fdtfile;bootm $loadaddr $ramdiskaddr $fdtaddr
ramdiskaddr=2000000
ramdiskfile=t2080rdb/ramdisk.uboot
rootpath=/opt/nfsroot
stderr=serial
stdin=serial
stdout=serial
tftpflash=tftpboot $loadaddr $uboot && protect off $ubootaddr +$filesize && erase $ubootaddr +$filesize && cp.b $loadaddr $ubootaddr $filesize && protect on
$ubootaddr +$filesize && cmp.b $loadaddr $ubootaddr $filesize
uboot="u-boot.bin"
ubootaddr=0x00201000

List of U-Boot commands

?       - alias for 'help'

base - print or set address offset

bdinfo - print Board Info structure

boot - boot default, i.e., run 'bootcmd'

bootd - boot default, i.e., run 'bootcmd'

bootelf - Boot from an ELF image in memory

bootm - boot application image from memory

bootp - boot image via network using BOOTP/TFTP protocol

bootvx - Boot vxWorks from an ELF image

chpart - change active partition

clrlogo - fill the boot logo area with black

cmp - memory compare

coninfo - print console devices and information

cp - memory copy

cpld - Reset the board or alternate bank

cpu - Multiprocessor CPU boot manipulation and release

crc32 - checksum calculation

dhcp - boot image via network using DHCP/TFTP protocol

echo - echo args to console

editenv - edit environment variable

env - environment handling commands

erase - erase FLASH memory

errata - Report errata workarounds

exit - exit script

ext2load- load binary file from a Ext2 filesystem

ext2ls - list files in a directory (default /)

false - do nothing, unsuccessfully

fatinfo - print information about filesystem

fatload - load binary file from a dos filesystem

fatls - list files in a directory (default /)

fatsize - determine a file's size

fdt - flattened device tree utility commands

flinfo - print FLASH memory information

go - start application at address 'addr'

hash - compute hash message digest

help - print command description/usage

i2c - I2C sub-system

iminfo - print header information for application image

imls - list all images found in flash

imxtract- extract a part of a multi-image

itest - return true/false on integer compare

loadb - load binary file over serial line (kermit mode)

loads - load S-Record file over serial line

loadx - load binary file over serial line (xmodem mode)

loady - load binary file over serial line (ymodem mode)

loop - infinite loop on address range

mac - display and program the system ID and MAC addresses in EEPROM

md - memory display

mdio - MDIO utility commands

mii - MII utility commands

mm - memory modify (auto-incrementing address)

mmc - MMC sub system

mmcinfo - display MMC info

mtdparts- define flash/nand partitions

mtest - simple RAM read/write test

mw - memory write (fill)

nand - NAND sub-system

nboot - boot from NAND device

nfs - boot image via network using NFS protocol

nm - memory modify (constant address)

pci - list and access PCI Configuration Space

ping - send ICMP ECHO_REQUEST to network host

printenv- print environment variables

protect - enable or disable FLASH write protection

reginfo - print register information

reset - Perform RESET of the CPU

run - run commands in an environment variable

sata - SATA sub system

saveenv - save environment variables to persistent storage

setenv - set environment variables

setexpr - set environment variable as the result of eval expression

sf - SPI flash sub-system

showvar - print local hushshell variables

sleep - delay execution for some time

source - run script from memory

test - minimal test like /bin/sh

tftpboot- boot image via network using TFTP protocol

true - do nothing, successfully

usb - USB sub-system

usbboot - boot from USB device

vdd_override- override VDD

vdd_read- read VDD

version - print monitor, compiler and linker version

Notes and Issues

Use of the provided Debian disk image with QEMU
You make use of the provided disk image with Debian pre-installed with QEMU, just download the kernel and the initrd image, and launch QEMU entering the following parameters

qemu-system-ppc64 -machine pseries -cpu power8 -smp 4 -m 4G -vga virtio -serial stdio -kernel ./book3s_ppc64_kernel_5.5.0-1 -initrd ./book3s_ppc64_initrd_5.5.0-1 -device spapr-vscsi -drive file=./hdd_debian_sid_ppc64.img,format=raw -append "root=/dev/sda"

No video output at boot time
Our current build of U-Boot does not initialize the video card, so the only way to deal with U-Boot at the moment is via a remote serial terminal. This problem must be solved for allowing more comfortable use of the T2080 dev system and our future laptop project, Which will be based around the T2080 SOC that is featured on the development board.

Non-working on-board ethernet ports (your help is needed here!)
I am unable to correctly initialize the onboard network ports, especially the Realtek RTL8211 PHYs (RGMII 10/100/1G Ethernet ports) network ports called ETH4 and ETH5. We think there are issues related to initializing DPAA, but we are not sure. More infos on the issue here:
https://gitlab.com/oshw-powerpc-notebook/T2080customizations/issues/1

It might be due to a missing Cortina PHY microcode as the kernel report the following error message:
Not found Cortina PHY ucode at 0x00114000

The Cortina microcode can be found here
https://gitlab.com/oshw-powerpc-notebook/T2080customizations/blob/master/cortina_microcode/cs4315-cs4340-PHY-ucode.txt

So, at the moment I connect the T2080RDB to the internet using either a USB WiFi adapter (in my case an old Zyxel G-220) or an USB-to-Ethernet adapter (in my case the following adapter that has an RTL8152 chipset https://www.amazon.it/gp/product/B002DFT4KW/)

USB Gigabit Ethernet dongle

Alternatively, if you are not willing to use a graphic card and have the PCI-E x4 empty as you plan to control the board remotely, you may want to use a Gigabit Ethernet card. We are successfully using a TP-Link TG-3468 at the moment, and we access graphically the board using the RDP protocol thanks to xrdp, and via console using SSH.

4GB of RAM is not really enough for serious use
The T2080RDB comes with a SO-DIMM module of 4GB of RAM, 1866 MT/s, PC3-14900, CL13, with ECC and running at 1.35V. Below a picture of the module that came with our board.

T2080RDB RAM SODIMM module DD3L  4GB 1866 CL13 ECC 1.35

So far, we were not able to find on the market any SO-DIMM module bigger than 4GB.

It seems DSL memory actually does 8 and 16GB DDR3L SO-DIMM boards rated at 1866Mhz with ECC, though we have not been able to find any suppliers of these, yet (see https://www.dsltech.com.tw/products/ddr3-sram/). These are the models available

D3XM12081XL10AA  4GB  (512Mx8)9EA   DDR3L-1866  MICRON  MP (1.35V)
D3XS12081XL10AA 4GB (512Mx8)9EA DDR3L-1866 SAMSUNG MP (1.35V)
D3XM12082XL10AA 8GB (512Mx8)18EA DDR3L-1866 MICRON MP (1.35V)
D3XS12082XL10AA 8GB (512Mx8)18EA DDR3L-1866 SAMSUNG MP (1.35V)

Another possible brand providing this kind of SO-DIMM modules is Crucial (see https://it.crucial.com/catalog/memory/ddr3) but there seems to be no ECC model available.

[update 20 April 2020] We have tried the Crucial CT102464BF186D, SO-DIMM 8Gb, 1866 MT/s, PC3-14900, CL13, non-ECC, https://www.crucial.com/memory/ddr3/ct102464bf186d
At boot U-Boot hangs with the following message

SD boot…
Initializing….using SPD
Waiting for D_INIT timeout. Memory may not work.
6 GiB left unmapped

I have created a post about it in our forum
https://forum.powerprogress.org/d/19-using-8gb-sodimm-module-on-the-t2080rdb

Finding a suitable Desktop case
The current case the T2080 dev board comes in isn’t really suitable if you intend to use the system as a desktop system etc. While I haven’t chosen an existing case for my system, I ended up making my own out of wood and some other readily available materials. See the link below for more information:
https://www.powerprogress.org/en/diy/do-it-yourself-wooden-desktop-case-for-the-t2080rdb/


Credits
Guide originally by: Mario Locati
Editorial by: Howard Rennie, William Toner