The ECM1900 and BRK1900 have been specifically chosen for this Getting Started Guide due to their complementary features. The ECM1900 is specifically designed as a compact and efficient platform for the Zynq MPSoC, whereas the BRK1900 functions as a comprehensive development board that not only provides power to the ECM1900 but also provides access to essential Processing System (PS) peripherals. Together, they provide a complete solution for evaluating and implementing the ECM1900, making them the perfect choice for this guide. The following are the learning objectives for this Getting Started Guide:

1. Requirements
   Lists the necessary requirements, such as hardware, software, and tools, required for working with this Getting Started Guide.
2. Prebuilt Linux Image
   Explains how to flash a microSD card with the prebuilt Linux image for the BRK1900 w/ ECM1900 device.
3. Power, Boot, and Serial Connection
   Provides instructions on powering on the BRK1900 w/ ECM1900, booting it up, and establishing a serial connection for communication.
4. Device Sensors
   Introduces the sensors on the ECM1900 device and how to configure and interact with them.
5. Si5341 Clock Generator
   Explains the process of configuring the Si5341 clock generator that is onboard the ECM1900 device.
6. Si5338 Clock Generator
   Guides users on how to configure the Si5338 clock generator that is onboard the BRK1900 device.
7. IO Bank Voltages
   Provides instructions on setting the voltages for the IO banks of the Zynq MPSoC on the ECM1900 device.
8. Configure a Bitfile
   Walks users through the process of configuring a bitfile for programming the BRK1900 w/ ECM1900 device.
9. MPSoC Vivado IP Core Configuration
   Explains the process of applying the BRK1900 configuration information to the Zynq Ultrascale+ MPSoC Vivado IP Core.
10. Processing System (PS) Side DisplayPort
    This guide roughly instructs users on how to get AMD’s Standalone DisplayPort example design working on the hardened DisplayPort 1.2 in the processing system (PS).
    

This section provides an overview of the hardware, software, and tools that are required for working through the BRK1900 w/ ECM1900 Getting Started Guide. It outlines the essential prerequisites that users need to have in place before proceeding:

• ECM1900
• BRK1900
• microSD card
• microSD card reader/writer
• Our latest prebuilt BRK1900LinuxImage-vX.Y.wic.zip download

This section explains the process of flashing a microSD card with the prebuilt Linux image specifically designed for the BRK1900 w/ ECM1900 device. It provides instructions on how to prepare the microSD card with the required Linux image.

Our Linux image is available in Wic format, which offers a simplified way to flash images to the microSD card. Wic includes built-in information on partitioning the drive for boot and rootfs, making the process more streamlined and efficient. Start by performing the following:

1. Extract our latest prebuilt BRK1900LinuxImage-vX.Y.wic.zip download.
2. Follow the instructions below for your operating system:

We recommend using Etcher or similar tools. Most of these tools support the Wic format.

Use the following command to flash the microSD card:

sudo dd if=BRK1900LinuxImage-vX.Y.wic of=/dev/sdb bs=1M status=progress

Explanation of the command:

• sudo: Runs the command with administrative privileges, required for writing to disks.
• dd: The command used for low-level data copying and conversion.
• if=BRK1900LinuxImage-vX.Y.wic: Specifies that our prebuilt .wic image should be used as the input source.
• of=/dev/sdb: Specifies the target disk to write to, in this example, the disk named “sdb”.
• bs=1M: Specifies the block size for reading and writing data, set to 1 megabyte (MB) in this example. You can adjust this value as needed.
• status=progress: Displays the progress of the operation in real-time, showing the amount of data written.

This section guides users on powering on the BRK1900 w/ ECM1900 device, booting up our provided Linux image, and establishing a serial connection for communication purposes.

1. Install the ECM1900 onto the BRK1900. See the Jack Screw Instructions.
2. Insert the microSD card containing the BRK1900 Linux image into the microSD card slot on the ECM1900.
3. Power the BRK1900 either through the DC barrel jack or the 6-pin Mini-Fin connector with a DC supply within the range of 6 V to 15 V. See ‘Powering the BRK1900’ at BRK1900 Breakout Board.
4. Plug in a USB type C cable from the USB UART port on the ECM1900 to a USB port of your host computer.
5. Establish a serial connection with the connected device at 115200 baud.
6. Wait for the boot sequence to finish before proceeding

This section provides guidance on how to run the Device Sensors application, which serves as an example implementation showcasing the sensor capabilities of our product. Please note that while this application can be used in an end design, it is intended to be a starting point that you can customize and modify to suit your specific design requirements. See the following resources for more information:

• Device Sensors documentation
• device-sensors Application

1. Navigate to the appropriate sample application folder:
   cd ~/tools/device-sensors/
2. Run the sample application:
   python3 device-sensors.py

This section provides instructions on how to configure the Si5341 Clock Generator on the ECM1900. The premade application provided here serves as an example implementation that you can use as a starting point and modify according to your design requirements. See the following resources for more information:

• ECM1900 Clock Generator
• set-clock-ecm1900 Application
• Clock Builder Pro Project Files

1. Navigate to the appropriate sample application folder:
   cd ~/tools/set-clock-ecm1900/
2. Optionally view the provided configuration.
   vim ECM1900-Si5341-Regs.h
3. Optionally substitute ECM1900-Si5341-Regs.h for a new configuration.
   See set-clock-ecm1900 Application README for more information.
4. Compile the application with the ECM1900-Si5341-Regs.h configuration:
   make
5. Run the sample application:
   ./set-clock-ecm1900 /dev/i2c-0

In this section, you will learn how to configure the Si5338 Clock Generator on the BRK1900. We provide a premade application that serves as an example implementation of clock configuration, which you can use as a foundation and tailor to your specific design needs. See the following resources for more information:

• BRK1900 Peripherals
• set-clock-brk1900 Application
• Clock Builder Pro Project Files

1. Navigate to the appropriate sample application folder:
   cd ~/tools/set-clock-brk1900/
2. Optionally view the provided configuration.
   vim BRK1900-Si5338-Regs.h
3. Optionally substitute BRK1900-Si5338-Regs.h for a new configuration.
   See set-clock-brk1900 Application README for more information.
4. Compile the application with the ECM1900-Si5341-Regs.h configuration:
   make
5. Run the sample application:
   ./set-clock-brk1900 -w /dev/i2c-0

In this section, you will learn how to set the IO bank voltages of the Zynq MPSoC on the ECM1900. The premade application provided here offers an example implementation for power rail configuration, which you can use as a reference and customize to meet the power requirements of your specific application. See the following resources for more information:

• Powering the ECM1900
• syzygy-ecm1900 Application

1. Run the sample application to set VIO1 (VCCO_87_88) to 3.3V:
   syzygy-ecm1900 -s -1 330 /dev/i2c-0
2. You can confirm that this rail has been properly set by measuring the VCCO_87_88 test point on the BRK1900 PCB board.

This section guides users on how to configure a bitfile for programming the PL side of the ECM1900 device.

1. Transfer your bitfile to the rootfs using UART, Ethernet, USB2, USB3, or by directly writing it to the rootfs partition on the microSD card.
2. Run the AMD-Xilinx provided fpgautil application to configure the PL side with your bitfile:
   fpgautil -b YOUR_BITFILE.bit

This section explains the process of applying our BRK1900 configuration information to the Zynq Ultrascale+ MPSoC Vivado IP Core. We provide this configuration through the BRK1900’s Vivado Board File. Communications between the PS and PL side will require an instantiation of the Zynq Ultrascale+ MPSoC Vivado IP Core in your Vivado design.

Required resources:

• BRK1900 Board File

1. Create a new Vivado project with the BRK1900 Board File
2. Create a new Block Design in the IP Integrator (IPI)
3. Instantiate the Zynq UltraScale+ MPSoC Vivado IP Core
4. A “Designer Assistance available.” notification will appear. Select “Run Block Automation.”
5. Ensure that “Apply Board Preset” is enabled
6. Click “OK”

This guide will roughly instruct the user on how to get AMD’s Standalone DisplayPort example design working on the hardened Displayport 1.2 in the processing system (PS).

1. Go through the MPSoC Vivado IP Core Configuration guide above.
2. Connect EMIO pins for the DisplayPort AUX to an IOBUFDS using the Utility Buffer IP core in the block designer.
3. Make the DisplayPort hot plug detect and AUX external ports in the block designer.
4. Generate the block design.
5. Create a wrapper for the block design.
6. Constrain the pin locations for the DP AUX and hot plug detect as documented at BRK1900 Peripherals.
7. Generate the bitstream.
8. File->Export Hardware, include the bitfile, export to .xsa.
9. Create a new “Platform Project” and import the XSA to Vitis.
10. Under standalone on psu_cortex, “Import Example” for the “dpdma” driver.
11. Add IIC (I2C1) to the system to configure the clock generator and the power supplies.
12. Use the IO Bank Voltages section above to help you power the rails.
13. Use the Si5338 Clock Generator section above to configure clock OUT2 to 27 MHz.
    Note: This clock needs to be available at boot. You can either add it to the FSBL or configure the clock and then restart the application without power cycling the board so that the clock is available at the time of boot.
14. For both the “IO Bank Voltages” and “Si5338 Clock Generator” sections, they are part of an application baked into Linux. This is not the case with AMD’s standalone DisplayPort example design. You will need to take some of that code and implement some of the functions from it to complete these actions in the standalone application.
15. In the “Platform Project” you created above, use the file navigator in Vitis to go to: <PlatformProject>/psu_cortexa53_0/standalone_domain/bsp/psu_cortexa53_0/libsrc/avbuf_v2_5/src/xavbuf_clk.c. Refer to AMD’s GitHub for the specific line: avbuf. Change the line to:
    define XAVBUF_INPUT_REF_CLK 5000000000
16. Build the Vitis project.
17. Run the Vitis project on the BRK1900 using a JTAG connection.