PINE64 - User contributions [en]

User:RemDogKap/SandBox/Build U-Boot and OpenSBI From Source

2023-10-29T03:01:13Z

RemDogKap: Removed placeholder text

==Preparing the Build Environment==
Fist, install the cross-compiler and if not already installed, git.
$ sudo apt update && sudo apt install gcc-riscv64-linux-gnu git
<span class="mw-customtoggle-gcc-version-toggle" style="text-decoration:underline;color:#0645ad">[Optional] Check the version of the <code>riscv64-linux-gnu-gcc</code> compiler.</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-gcc-version-toggle">
$ riscv64-linux-gnu-gcc -v
The output should looks something like:
<pre>
Using built-in specs.
COLLECT_GCC=riscv64-linux-gnu-gcc
COLLECT_LTO_WRAPPER=usr/lib/gcc-cross/riscv64-linux-gnu/10/lto-wrapper
Target: riscv64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Debian 10.2.1-6' --with-bugurl=file:///usr/share/doc/gcc-10/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-10 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-libitm --disable-libsanitizer --disable-libquadmath --disable-libquadmath-support --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --without-target-system-zlib --enable-multiarch --disable-werror --disable-multilib --with-arch=rv64imafdc --with-abi=lp64d --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=riscv64-linux-gnu --program-prefix=riscv64-linux-gnu- --includedir=/usr/riscv64-linux-gnu/include --with-build-config=bootstrap-lto-lean --enable-link-mutex
Thread model: posix
Supported LTO compression algorithms: zlib
gcc version 10.2.1 20210110 (Debian 10.2.1-6)
</pre>
</div>

Create or enter the directory where the files used in this guide will be stored. This tutorial will be using the Linux home directory.

<span class="mw-customtoggle-home-directory-example" style="text-decoration:underline;color:#0645ad">Home Directory Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-home-directory-example">
$ cd ~
</div>
<span class="mw-customtoggle-new-directory-example" style="text-decoration:underline;color:#0645ad">New Directory Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-new-directory-example">
$ mkdir ~/Star64-Firmware
$ cd ~/Star64-Firmware/
</div>
Clone the StarFive Tools GitHub repository. This will be used to create the <code>.bin.normal.out</code> SPL image and provide the <code>.its</code> FIT image tree source file which provides the configuration for the <code>.img</code> U-Boot image file.

$ git clone --depth 1 https://github.com/starfive-tech/Tools
Compile the SPL Tool used to create the SPL image in the <code><working_directory>/Tools/spl_tool/</code> directory using <code>make</code>.
$ make -C Tools/spl_tool/
==U-Boot==

Clone the U-Boot GitHub repository. The entire history is not needed (<code>--depth 1</code>) and we want the Star64 branch (<code>-b Star64</code>).
$ git clone --depth 1 -b Star64 <nowiki>https://github.com/Fishwaldo/u-boot.git</nowiki>
Enter the U-Boot directory.
$ cd u-boot/
Select the U-Boot configuration for the Star64, marking the architecture as RISC-V (<code>ARCH=riscv</code>) and using the cross-compiler installed earlier(<code>CROSS_COMPILE=riscv64-linux-gnu-</code>).
$ make pine64_star64_defconfig ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu-
Finally, compile U-Boot.
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu-
This should create three files.
# The U-Boot binary, later packaged as an OpenSBI payload, located at <code><working_directory>/u-boot/u-boot.bin</code>.
# The device tree blob (binary), which contains information on the characteristics of the device and is passed to the operating system instead of hard-coding device configurations into the operating system, and is located at <code><working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb</code>.
# The U-Boot secondary program loader which will later be packaged into the <code>u-boot-spl.bin.normal.out</code> file and is located at <code><working_directory>/u-boot/spl/u-boot-spl.bin</code>.
==OpenSBI==
Return to the directory where the files for this build are stored. In this case it is the Linux home directory. Unless you have since changed directories,
$ cd ..
should return to to the directory before the U-Boot section.

Clone the OpenSBI U-Boot repository and enter its directory. The entire history is not needed (<code>--depth 1</code>).
$ git clone --depth 1 <nowiki>https://github.com/riscv/opensbi.git</nowiki>
$ cd opensbi/
Compile OpenSBI using <code>make</code>. Make sure to set
# the architecture as RISC-V (<code>ARCH=riscv</code>)
# the compiler as the cross-compiler installed earlier (<code>CROSS_COMPILE=riscv64-linux-gnu-</code>)
# the platform as generic (<code>PLATFORM=generic</code>)
# the OpenSBI payload path as the path to the <code>u-boot.bin</code> file created in the [[#U-Boot|U-Boot]] step (<code>FW_PAYLOAD_PATH=<working_directory>/u-boot/u-boot.bin</code>)
# the flattened device tree (device tree blob) as the <code>pine64_star64.dtb</code> file created in the [[#U-Boot|U-Boot]] step (<code>FW_FDT_PATH=<working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb</code>)
# <code>FW_TEXT_START</code> as <code>0x40000000</code> (<code>FW_TEXT_START=0x40000000</code>).
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- PLATFORM=generic FW_PAYLOAD_PATH=<working_directory>/u-boot/u-boot.bin FW_FDT_PATH=<working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb FW_TEXT_START=0x40000000
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-compile-opensbi-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-compile-opensbi-example">
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- PLATFORM=generic FW_PAYLOAD_PATH=~/u-boot/u-boot.bin FW_FDT_PATH=~/u-boot/arch/riscv/dts/pine64_star64.dtb FW_TEXT_START=0x40000000
</div>
This should create one file, <code>fw_payload.bin</code>, which contains OpenSBI with U-Boot as the payload. The file is located at <code>opensbi/build/platform/generic/firmware/fw_payload.bin</code>.

==Creating the SPL File==
Go to the directory the SPL Tool compiled earlier is located in. If these instructions were followed exactly the following should work:
$ cd ../Tools/spl_tool/
Use the SPL Tool to create the <code>u-boot-spl.bin.normal.out</code> SPL image.
$ ./spl_tool -c -f <working_directory>/u-boot/spl/u-boot-spl.bin
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-spl-tool-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-spl-tool-example">
$ ./spl_tool -c -f ~/u-boot/spl/u-boot-spl.bin
</div>
This should produce a <code>u-boot-spl.bin.normal.out</code> file located at <code><working_directory>/u-boot/spl/u-boot-spl.bin.normal.out</code>
==Creating the fw_payload File==
Return to the directory where the files for this build are stored. In this case it is the Linux home directory. Unless you have since changed directories,
$ cd ..
should work.

Enter the <code><working_directory>/Tools/uboot_its/</code> directory which holds the <code>.its</code> FIT image tree source file which provides the configuration for the <code>.img</code> U-Boot image file.
$ cd Tools/uboot_its/
The process of making the U-Boot image requires the <code>fw_payload.bin</code> created earlier so copy that to the current directory.
$ cp <working_directory>/opensbi/build/platform/generic/firmware/fw_payload.bin ./
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-fw_payload-cp-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-fw_payload-cp-example">
$ cp ~/opensbi/build/platform/generic/firmware/fw_payload.bin ./
</div>
Make the <code>star64_fw_payload.img</code> U-Boot image file using the U-Boot <code>mkimage</code> tool. The <code>mkimage</code> tool is located in the <code><working_directory>/u-boot/tools/</code> directory but requires the <code>visionfive2-uboot-fit-image.its</code> file which is located in <code><working_directory>/Tools/uboot_its/</code> so should be executed in the <code>uboot_its</code> directory.
$ <working_directory>/tools/mkimage -f visionfive2-uboot-fit-image.its -A riscv -O u-boot -T firmware star64_fw_payload.img
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-mkimage-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-mkimage-example">
$ ~/u-boot/tools/mkimage -f visionfive2-uboot-fit-image.its -A riscv -O u-boot -T firmware star64_fw_payload.img
</div>
There is currently no <code>.its</code> file specifically for the Star64 so the VisionFive2's <code>.its</code> file is used instead as they share a processor.

This should produce a file called <code>star64_fw_payload.img</code> in the <code><working_directory>/Tools/uboot_its/</code> directory
==Credits==
https://doc-en.rvspace.org/VisionFive2/SWTRM/VisionFive2_SW_TRM/compiling_u-boot_and_kernel%20-%20vf2.html
https://wiki.pine64.org/wiki/User:Vitali/Create_a_bootable_Debian/Linux_SDCard_for_the_Pine64/Star64_from_scratch

User:RemDogKap/SandBox/Build U-Boot and OpenSBI From Source

2023-06-26T05:12:09Z

RemDogKap: completed writing guide

Placeholder intro and explanation, I'm tired don't want to write now, contributions welcome

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
* Must use linux, can use wsl

==Preparing the Build Environment==
Fist, install the cross-compiler and if not already installed, git.
$ sudo apt update && sudo apt install gcc-riscv64-linux-gnu git
<span class="mw-customtoggle-gcc-version-toggle" style="text-decoration:underline;color:#0645ad">[Optional] Check the version of the <code>riscv64-linux-gnu-gcc</code> compiler.</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-gcc-version-toggle">
$ riscv64-linux-gnu-gcc -v
The output should looks something like:
<pre>
Using built-in specs.
COLLECT_GCC=riscv64-linux-gnu-gcc
COLLECT_LTO_WRAPPER=usr/lib/gcc-cross/riscv64-linux-gnu/10/lto-wrapper
Target: riscv64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Debian 10.2.1-6' --with-bugurl=file:///usr/share/doc/gcc-10/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-10 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-libitm --disable-libsanitizer --disable-libquadmath --disable-libquadmath-support --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --without-target-system-zlib --enable-multiarch --disable-werror --disable-multilib --with-arch=rv64imafdc --with-abi=lp64d --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=riscv64-linux-gnu --program-prefix=riscv64-linux-gnu- --includedir=/usr/riscv64-linux-gnu/include --with-build-config=bootstrap-lto-lean --enable-link-mutex
Thread model: posix
Supported LTO compression algorithms: zlib
gcc version 10.2.1 20210110 (Debian 10.2.1-6)
</pre>
</div>

Create or enter the directory where the files used in this guide will be stored. This tutorial will be using the Linux home directory.

<span class="mw-customtoggle-home-directory-example" style="text-decoration:underline;color:#0645ad">Home Directory Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-home-directory-example">
$ cd ~
</div>
<span class="mw-customtoggle-new-directory-example" style="text-decoration:underline;color:#0645ad">New Directory Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-new-directory-example">
$ mkdir ~/Star64-Firmware
$ cd ~/Star64-Firmware/
</div>
Clone the StarFive Tools GitHub repository. This will be used to create the <code>.bin.normal.out</code> SPL image and provide the <code>.its</code> FIT image tree source file which provides the configuration for the <code>.img</code> U-Boot image file.

$ git clone --depth 1 https://github.com/starfive-tech/Tools
Compile the SPL Tool used to create the SPL image in the <code><working_directory>/Tools/spl_tool/</code> directory using <code>make</code>.
$ make -C Tools/spl_tool/
==U-Boot==

Clone the U-Boot GitHub repository. The entire history is not needed (<code>--depth 1</code>) and we want the Star64 branch (<code>-b Star64</code>).
$ git clone --depth 1 -b Star64 <nowiki>https://github.com/Fishwaldo/u-boot.git</nowiki>
Enter the U-Boot directory.
$ cd u-boot/
Select the U-Boot configuration for the Star64, marking the architecture as RISC-V (<code>ARCH=riscv</code>) and using the cross-compiler installed earlier(<code>CROSS_COMPILE=riscv64-linux-gnu-</code>).
$ make pine64_star64_defconfig ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu-
Finally, compile U-Boot.
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu-
This should create three files.
# The U-Boot binary, later packaged as an OpenSBI payload, located at <code><working_directory>/u-boot/u-boot.bin</code>.
# The device tree blob (binary), which contains information on the characteristics of the device and is passed to the operating system instead of hard-coding device configurations into the operating system, and is located at <code><working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb</code>.
# The U-Boot secondary program loader which will later be packaged into the <code>u-boot-spl.bin.normal.out</code> file and is located at <code><working_directory>/u-boot/spl/u-boot-spl.bin</code>.
==OpenSBI==
Return to the directory where the files for this build are stored. In this case it is the Linux home directory. Unless you have since changed directories,
$ cd ..
should return to to the directory before the U-Boot section.

Clone the OpenSBI U-Boot repository and enter its directory. The entire history is not needed (<code>--depth 1</code>).
$ git clone --depth 1 <nowiki>https://github.com/riscv/opensbi.git</nowiki>
$ cd opensbi/
Compile OpenSBI using <code>make</code>. Make sure to set
# the architecture as RISC-V (<code>ARCH=riscv</code>)
# the compiler as the cross-compiler installed earlier (<code>CROSS_COMPILE=riscv64-linux-gnu-</code>)
# the platform as generic (<code>PLATFORM=generic</code>)
# the OpenSBI payload path as the path to the <code>u-boot.bin</code> file created in the [[#U-Boot|U-Boot]] step (<code>FW_PAYLOAD_PATH=<working_directory>/u-boot/u-boot.bin</code>)
# the flattened device tree (device tree blob) as the <code>pine64_star64.dtb</code> file created in the [[#U-Boot|U-Boot]] step (<code>FW_FDT_PATH=<working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb</code>)
# <code>FW_TEXT_START</code> as <code>0x40000000</code> (<code>FW_TEXT_START=0x40000000</code>).
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- PLATFORM=generic FW_PAYLOAD_PATH=<working_directory>/u-boot/u-boot.bin FW_FDT_PATH=<working_directory>/u-boot/arch/riscv/dts/pine64_star64.dtb FW_TEXT_START=0x40000000
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-compile-opensbi-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-compile-opensbi-example">
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- PLATFORM=generic FW_PAYLOAD_PATH=~/u-boot/u-boot.bin FW_FDT_PATH=~/u-boot/arch/riscv/dts/pine64_star64.dtb FW_TEXT_START=0x40000000
</div>
This should create one file, <code>fw_payload.bin</code>, which contains OpenSBI with U-Boot as the payload. The file is located at <code>opensbi/build/platform/generic/firmware/fw_payload.bin</code>.

==Creating the SPL File==
Go to the directory the SPL Tool compiled earlier is located in. If these instructions were followed exactly the following should work:
$ cd ../Tools/spl_tool/
Use the SPL Tool to create the <code>u-boot-spl.bin.normal.out</code> SPL image.
$ ./spl_tool -c -f <working_directory>/u-boot/spl/u-boot-spl.bin
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-spl-tool-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-spl-tool-example">
$ ./spl_tool -c -f ~/u-boot/spl/u-boot-spl.bin
</div>
This should produce a <code>u-boot-spl.bin.normal.out</code> file located at <code><working_directory>/u-boot/spl/u-boot-spl.bin.normal.out</code>
==Creating the fw_payload File==
Return to the directory where the files for this build are stored. In this case it is the Linux home directory. Unless you have since changed directories,
$ cd ..
should work.

Enter the <code><working_directory>/Tools/uboot_its/</code> directory which holds the <code>.its</code> FIT image tree source file which provides the configuration for the <code>.img</code> U-Boot image file.
$ cd Tools/uboot_its/
The process of making the U-Boot image requires the <code>fw_payload.bin</code> created earlier so copy that to the current directory.
$ cp <working_directory>/opensbi/build/platform/generic/firmware/fw_payload.bin ./
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-fw_payload-cp-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-fw_payload-cp-example">
$ cp ~/opensbi/build/platform/generic/firmware/fw_payload.bin ./
</div>
Make the <code>star64_fw_payload.img</code> U-Boot image file using the U-Boot <code>mkimage</code> tool. The <code>mkimage</code> tool is located in the <code><working_directory>/u-boot/tools/</code> directory but requires the <code>visionfive2-uboot-fit-image.its</code> file which is located in <code><working_directory>/Tools/uboot_its/</code> so should be executed in the <code>uboot_its</code> directory.
$ <working_directory>/tools/mkimage -f visionfive2-uboot-fit-image.its -A riscv -O u-boot -T firmware star64_fw_payload.img
Make sure to replace <code><working_directory></code> with the directory created or chosen in [[#Preparing_the_Build_Environment|Preparing the Build Environment]].
<span class="mw-customtoggle-mkimage-example" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-mkimage-example">
$ ~/u-boot/tools/mkimage -f visionfive2-uboot-fit-image.its -A riscv -O u-boot -T firmware star64_fw_payload.img
</div>
There is currently no <code>.its</code> file specifically for the Star64 so the VisionFive2's <code>.its</code> file is used instead as they share a processor.

This should produce a file called <code>star64_fw_payload.img</code> in the <code><working_directory>/Tools/uboot_its/</code> directory
==Credits==
https://doc-en.rvspace.org/VisionFive2/SWTRM/VisionFive2_SW_TRM/compiling_u-boot_and_kernel%20-%20vf2.html
https://wiki.pine64.org/wiki/User:Vitali/Create_a_bootable_Debian/Linux_SDCard_for_the_Pine64/Star64_from_scratch

User:RemDogKap/SandBox/Build U-Boot and OpenSBI From Source

2023-06-26T00:22:34Z

RemDogKap: OpenSBI section written

User:RemDogKap/SandBox/Build U-Boot and OpenSBI From Source

2023-06-25T23:02:54Z

RemDogKap: set up compilation environment and build u-boot sections written

User:RemDogKap/SandBox/Build U-Boot and OpenSBI From Source

2023-06-25T18:31:22Z

RemDogKap: Created page with "Placeholder intro and explanation, I'm tired don't want to write now, contributions welcome Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident,..."

User:RemDogKap/SandBox

2023-06-25T02:47:46Z

RemDogKap: added Build U-Boot and OpenSBI From Source

{{Under construction}}

Links to documentation pages I am currently working on for the Star64 SBC

ToDo:
*Explain that SD Card does not work at full speed
*Tutorial for loading disk images onto eMMC
*How to update XSPI U-Boot
*How to use NVME drives
*working state of various USB ports
*list hardware bugs
**SD Card Voltage
**USB over current
*Armbian Install
*Memory DTB fix/recompile eeprom thing
*How to flash eMMC from SD card if possible
*Things needed to build you own working image
*How to connect over serial

[[/First Setup]]

[[/Status of Features]]

[[/Build Your Own Image]]

[[/Update XSPI Flash SPL and U-Boot]]

[[/Build U-Boot and OpenSBI From Source]]

[[Recovering the Bootloader for STAR64 JH7710 over serial using screen]]

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-17T02:58:54Z

RemDogKap: formatting

{{Under construction}}
{{Warning | Attempting these instructions may permanently brick (make nonfunctional) your device. Do not attempt unless you know what you are doing.}}
{{Warning | These instructions have not been tested or verified. Use at your own risk.}}

The Star64 ships with an integrated 128 megabit (16 megabyte) xSPI NOR flash. Loaded on this flash from the factory is firmware called U-Boot and SPL but an old version designed for the StarFive VisionFive 2 SBC which may have incompatibilities with the Star64. The firmware on this flash is known as Das U-Boot, commonly just U-Boot which is an open-source primary boot loader. It performs similar functions to the BIOS on x86 platforms. The SPL or Secondary Program Loader is the software that loads U-Boot, which in turn loads the Linux kernel.

There are two main ways to update the xSPI flash. The first uses the <code>flashcp</code> command which requires the Star64 to first boot into an OS. This method may not work on older versions of [firmware, os, something else????]. The other method requires only the ability to load U-Boot and uses TFTP and the U-Boot <code>tftpboot</code> command.

==Prerequisites==
Required:
*Star64 SBC
*Computer running Linux, MacOS, or Windows
Possibly required:
*Ability to communicate over TTL (transistor to transistor logic) UART
*Ability to network the Star64 to a computer over ethernet

==flashcp==
First, connect to your Star64 over UART or with a mouse, keyboard, and monitor.
Next, install the <code>mtd-utils</code> package onto the Star64 if not already installed. This package is a set of tools that allow access to raw flash storage devices such as the xSPI flash. Also install <code>wget</code> if not already installed. These instructions assume that you are using the <code>deb</code> package manager.
$ sudo apt update && sudo apt install mtb-utils wget

Next, using <code>wget</code> download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image onto the.
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Next, print out the list of MTD (Memory Technology Device) raw flash devices using <code>cat</code>.
$ cat /proc/mtd

The output should look something like this:
<pre>
dev: size erasesize name
mtd0: 00020000 00001000 "spl"
mtd1: 00300000 00001000 "uboot"
mtd2: 00100000 00001000 "data"
</pre>

Finally, write the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image. to the respective partitions using <code>flashcp</code>, a command which writes to raw flash devices with more protections than <code>dd</code>.
$ flashcp -v [fishwaldo spl file name here].bin.normal.out /dev/<SPL Partition>
$ flashcp -v [fishwaldo uboot img file name here].img /dev/<U-Boot Partition>
Where <code><SPL Partition></code> is the partition name found under the "dev" column for the row "spl" from the cat printout, in this case <code>mtd0</code> and <code><U-Boot Partition></code> is the partition name found under the "dev" column for the row "uboot" in the cat printout, in this case <code>mtd1</code>.

At this point your xSPI flash has been rewritten and only a system restart is needed for the changes to take effect.

==tftpboot==
The <code>tftpboot</code> method uses a TFTP (Trivial File Transfer Protocol, a protocol which allows for basic file transfer functionality without authentication) server to transfer the SPL file and U-Boot image from a host computer to the Star64 running U-Boot and using the <code>tftpboot</code> command and then written to flash using the <code>sf</code> command which is a U-Boot command used to access SPI flash.

===Preparing The TFTP Server===
====Linux====
First, on your computer (not the Star64) install a TFTP server and <code>wget</code> if you do not already have it.
$ sudo apt update && sudo apt install tftpd-hpa wget
Next, check that the TFPT server is running using <code>systemctl</code>.
$ sudo systemctl status tftpd-hpa
This should output somethng like

<span style="color:#16c60c">●</span> tftpd-hpa.service - LSB: HPA's tftp server
Loaded: loaded (/etc/init.d/tftpd-hpa; generated)
Active: <span style="color:#16c60c">active (running)</span> since Sat 2023-06-10 20:51:28 CDT; 17min ago
Docs: man:systemd-sysv-generator(8)
Process: 1016 ExecStart=/etc/init.d/tftpd-hpa start (code=exited, status=0/SUCCESS)
Tasks: 1 (limit: 2306)
Memory: 588.0K
CPU: 23ms
CGroup: /system.slice/tftpd-hpa.service
└─1023 /usr/sbin/in.tftpd --listen --user tftp --address :69 --secure /srv/tftp

Jun 10 20:51:28 debian-bookworm systemd[1]: Starting tftpd-hpa.service - LSB: HPA's tftp server...
Jun 10 20:51:28 debian-bookworm tftpd-hpa[1016]: Starting HPA's tftpd: in.tftpd.
Jun 10 20:51:28 debian-bookworm systemd[1]: Started tftpd-hpa.service - LSB: HPA's tftp server.

If the service is not running, try
$ sudo systemctl start tftpd-hpa
and check the status again. If it is still not running please join the #star64 channel in the Pine64 IRC, Discord, or Matrix.

Next, edit the configuration file for <code>tftpd-hpa</code>.
$ sudo nano /etc/default/tftpd-hpa
by default it should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/srv/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Change <code>TFTP_DIRECTORY="/srv/tftp"</code> to <code>TFTP_DIRECTORY="/home/user/tftp_share"</code>. The final file should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/home/<user>/tftp_share"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Where <code>user</code> is your username.
After that, save and close the file then restart the TFTP server.
$ sudo systemctl restart tftpd-hpa

Next in your home directory (<code>/home/user</code>) create a folder called <code>tftp_share</code>
$ mkdir /home/user/tftp_share
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image using <code>wget</code>.
$ cd /home/user/tftp_share
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Before connecting to the Star64 and updating the firmware install minicom, virtual console software, so it will be possible to communicate with the Star64.
$ sudo apt update && sudo apt install minicom
Next connect the your USB to TTL UART adapter to the computer and list the connected serial devices.
$ dmesg | grep tty
Example output:
<pre>
to be
filled in
later
</pre>
Find the address of the TTL UART to USB adapter in the list (example: <code>ttyUSB0</code>) and connect to the serial device with a baud rate of 115200.
$ sudo minicom -D /dev/<Device Address> -b 115200
Where <code><Device Address></code> is the address found in the step above. <span class="mw-customtoggle-device-address-toggle" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-device-address-toggle">
$ sudo minicom -D /dev/ttyUSB0 -b 115200
</div>

====Windows====

First, install two pieces of software, [https://pjo2.github.io/tftpd64/ tftpd64], a TFTP server for windows, and [http://ttssh2.osdn.jp/index.html.en Tera Term], a virtual console for interacting with the Star64 in U-Boot.
Next on your desktop, create a folder called <code>tftp_share</code>
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image from [https://pine64.my-ho.st:8443/ here].

Next, load tftpd64 and configure the settings to have the "Current Directory" as the <code>tftp_share</code> folder on the desktop and "Server interfaces" is set to <code>127.0.0.1 Software Loopback Interface 1</code>. The path should look something like <code>C:\Users\${Username}\Desktop\tftp_share</code> where <code>${Username}</code> is your username on Windows.
[[File:Star64 tftpd64 settings.png|none|500px|thumb|left]]

===Updating the SPI Flash===

Next, connect a TTL UART to USB cable to to the Star64 with the GND cable on pin 6 of the GPIO header, TXD on pin 8, and RXD on pin 10 as well as ethernet. Note that depending on your UART adapter you may have to switch TXD and RXD. Now power on the Star64 and enter U-Boot. You will need to press a key to prevent it from autobooting and instead enter the U-Boot command prompt.
Once you are in the U-Boot shell set some environment variables.
First, set the IP address of the Star64 and connect it to the network using the <code>dhcp</code> command.
# dhcp

Set an environment variable of the TFTP server to make future command easier. If you don't what the IP address of your TFTP server is you can see connected devices in your router's configuration which can usually be accessed by typing in the IP address found on the router itself.
# setenv <server IP>
Where <code>server IP</code> is the IP address of the TFTP server. <span class="mw-customtoggle-set-ip-addr-toggle" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-set-ip-addr-toggle">
# setenv 192.168.1.199
</div>
Ping the TFTP server from the Star64 to make sure the connection works where <code><Server IP></code> refers to the IP address of your TFTP server. Note that if you are hosting the TFTP server on Windows, you may need to configure Windows firewall to allow <code>‘File and Printer Sharing (Echo Request – ICMPv4 – In)’</code>. This is only needed to test the network connection with <code>ping</code> and not for the actual <code>tftpboot</code> command so if <code>ping</code> fails <code>tftpboot</code> may still succeed.
# ping <Server IP>
<span class="mw-customtoggle-ping-ip-addr-toggle" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-ping-ip-addr-toggle">
# ping 192.168.1.228
</div>
The result should look something like this:
<pre>
Star64 # ping 192.168.1.199
Using ethernet@16030000 device
host 192.168.1.199 is alive
</pre>
If ping fails, please try again or please join the #star64 channel in the Pine64 IRC, Discord, or Matrix for help.

Finally, it is time to update the xSPI flash.

First, initialize the flash with the <code>sf probe</code> command.
# sf probe
The output should be something like:
<pre>
Star64 # sf probe
SF: Detected gd25lq128 with page size 256 Bytes, erase size 4 KiB, total 16 MiB
</pre>
Next copy the SPL <code>.bin.normal.out</code> file to memory address 0xa0000000 from our TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo spl file]
Where ${serverip} is the environment variable we set earlier, no need to change it.
Then use <code>sf update</code> to erase and update the SPI flash from memory. In this case we are copying from memory address 0xa0000000 which we wrote to earlier with an offset of 0x0.

# sf update 0xa0000000 0x0 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Next, copy the U-Boot <code>.img</code> binary to memory address 0xa0000000 from the TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo uboot image]
Where ${serverip} is the environment variable we set earlier, no need to change it.

Finally, write the new U-Boot binary using <code>sf update</code> from memory address 0xa0000000 with an offset of 0x100000.
# sf update 0xa0000000 0x100000 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Reboot the Star64 and the changes should have taken effect.

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-17T02:45:20Z

RemDogKap: minor formatting updates

{{Under construction}}
{{Warning | Attempting these instructions may permanently brick (make nonfunctional) your device. Do not attempt unless you know what you are doing.}}
{{Warning | These instructions have not been tested or verified. Use at your own risk.}}

The Star64 ships with an integrated 128 megabit (16 megabyte) xSPI NOR flash. Loaded on this flash from the factory is firmware called U-Boot and SPL but an old version designed for the StarFive VisionFive 2 SBC which may have incompatibilities with the Star64. The firmware on this flash is known as Das U-Boot, commonly just U-Boot which is an open-source primary boot loader. It performs similar functions to the BIOS on x86 platforms. The SPL or Secondary Program Loader is the software that loads U-Boot, which in turn loads the Linux kernel.

There are two main ways to update the xSPI flash. The first uses the <code>flashcp</code> command which requires the Star64 to first boot into an OS. This method may not work on older versions of [firmware, os, something else????]. The other method requires only the ability to load U-Boot and uses TFTP and the U-Boot <code>tftpboot</code> command.

==Prerequisites==
Required:
*Star64 SBC
*Computer running Linux, MacOS, or Windows
Possibly required:
*Ability to communicate over TTL (transistor to transistor logic) UART
*Ability to network the Star64 to a computer over ethernet

==flashcp==
First, connect to your Star64 over UART or with a mouse, keyboard, and monitor.
Next, install the <code>mtd-utils</code> package onto the Star64 if not already installed. This package is a set of tools that allow access to raw flash storage devices such as the xSPI flash. Also install <code>wget</code> if not already installed. These instructions assume that you are using the <code>deb</code> package manager.
$ sudo apt update && sudo apt install mtb-utils wget

Next, using <code>wget</code> download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image onto the.
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Next, print out the list of MTD (Memory Technology Device) raw flash devices using <code>cat</code>.
$ cat /proc/mtd

The output should look something like this:
<pre>
dev: size erasesize name
mtd0: 00020000 00001000 "spl"
mtd1: 00300000 00001000 "uboot"
mtd2: 00100000 00001000 "data"
</pre>

Finally, write the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image. to the respective partitions using <code>flashcp</code>, a command which writes to raw flash devices with more protections than <code>dd</code>.
$ flashcp -v [fishwaldo spl file name here].bin.normal.out /dev/<SPL Partition>
$ flashcp -v [fishwaldo uboot img file name here].img /dev/<U-Boot Partition>
Where <code><SPL Partition></code> is the partition name found under the "dev" column for the row "spl" from the cat printout, in this case <code>mtd0</code> and <code><U-Boot Partition></code> is the partition name found under the "dev" column for the row "uboot" in the cat printout, in this case <code>mtd1</code>.

At this point your xSPI flash has been rewritten and only a system restart is needed for the changes to take effect.

==tftpboot==
The <code>tftpboot</code> method uses a TFTP (Trivial File Transfer Protocol, a protocol which allows for basic file transfer functionality without authentication) server to transfer the SPL file and U-Boot image from a host computer to the Star64 running U-Boot and using the <code>tftpboot</code> command and then written to flash using the <code>sf</code> command which is a U-Boot command used to access SPI flash.

===Preparing The TFTP Server===
====Linux====
First, on your computer (not the Star64) install a TFTP server and <code>wget</code> if you do not already have it.
$ sudo apt update && sudo apt install tftpd-hpa wget
Next, check that the TFPT server is running using <code>systemctl</code>.
$ sudo systemctl status tftpd-hpa
This should output somethng like

<span style="color:#16c60c">●</span> tftpd-hpa.service - LSB: HPA's tftp server
Loaded: loaded (/etc/init.d/tftpd-hpa; generated)
Active: <span style="color:#16c60c">active (running)</span> since Sat 2023-06-10 20:51:28 CDT; 17min ago
Docs: man:systemd-sysv-generator(8)
Process: 1016 ExecStart=/etc/init.d/tftpd-hpa start (code=exited, status=0/SUCCESS)
Tasks: 1 (limit: 2306)
Memory: 588.0K
CPU: 23ms
CGroup: /system.slice/tftpd-hpa.service
└─1023 /usr/sbin/in.tftpd --listen --user tftp --address :69 --secure /srv/tftp

Jun 10 20:51:28 debian-bookworm systemd[1]: Starting tftpd-hpa.service - LSB: HPA's tftp server...
Jun 10 20:51:28 debian-bookworm tftpd-hpa[1016]: Starting HPA's tftpd: in.tftpd.
Jun 10 20:51:28 debian-bookworm systemd[1]: Started tftpd-hpa.service - LSB: HPA's tftp server.

If the service is not running, try
$ sudo systemctl start tftpd-hpa
and check the status again. If it is still not running please join the #star64 channel in the Pine64 IRC, Discord, or Matrix.

Next, edit the configuration file for <code>tftpd-hpa</code>.
$ sudo nano /etc/default/tftpd-hpa
by default it should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/srv/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Change <code>TFTP_DIRECTORY="/srv/tftp"</code> to <code>TFTP_DIRECTORY="/home/user/tftp_share"</code>. The final file should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/home/<user>/tftp_share"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Where <code>user</code> is your username.
After that, save and close the file then restart the TFTP server.
$ sudo systemctl restart tftpd-hpa

Next in your home directory (<code>/home/user</code>) create a folder called <code>tftp_share</code>
$ mkdir /home/user/tftp_share
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image using <code>wget</code>.
$ cd /home/user/tftp_share
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Before connecting to the Star64 and updating the firmware install minicom, virtual console software, so it will be possible to communicate with the Star64.
$ sudo apt update && sudo apt install minicom
Next connect the your USB to TTL UART adapter to the computer and list the connected serial devices.
$ dmesg | grep tty
Example output:
<pre>
to be
filled in
later
</pre>
Find the address of the TTL UART to USB adapter in the list (example: <code>ttyUSB0</code>) and connect to the serial device with a baud rate of 115200.
$ sudo minicom -D /dev/<Device Address> -b 115200
Where <code><Device Address></code> is the address found in the step above. <span class="mw-customtoggle-device-address-toggle" style="text-decoration:underline;color:#0645ad">Example</span>
<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-device-address-toggle">
$ sudo minicom -D /dev/ttyUSB0 -b 115200
</div>

====Windows====

First, install two pieces of software, [https://pjo2.github.io/tftpd64/ tftpd64], a TFTP server for windows, and [http://ttssh2.osdn.jp/index.html.en Tera Term], a virtual console for interacting with the Star64 in U-Boot.
Next on your desktop, create a folder called <code>tftp_share</code>
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image from [https://pine64.my-ho.st:8443/ here].

Next, load tftpd64 and configure the settings to have the "Current Directory" as the <code>tftp_share</code> folder on the desktop and "Server interfaces" is set to <code>127.0.0.1 Software Loopback Interface 1</code>. The path should look something like <code>C:\Users\${Username}\Desktop\tftp_share</code> where <code>${Username}</code> is your username on Windows.
[[File:Star64 tftpd64 settings.png|none|500px|thumb|left]]

===Updating the SPI Flash===

Next, connect a TTL UART to USB cable to to the Star64 with the GND cable on pin 6 of the GPIO header, TXD on pin 8, and RXD on pin 10 as well as ethernet. Note that depending on your UART adapter you may have to switch TXD and RXD. Now power on the Star64 and enter U-Boot. You will need to press a key to prevent it from autobooting and instead enter the U-Boot command prompt.
Once you are in the U-Boot shell set some environment variables.
First, set the IP address of the Star64 and connect it to the network using the <code>dhcp</code> command.
# dhcp

Ping the TFTP server from the Star64 to make sure the connection works where <code>${Server IP}</code> refers to the IP address of your TFTP server. If you don't what the IP address of your TFTP server is you can see connected devices in your router's configuration which can usually be accessed by typing in the IP address found on the router itself. Note that if you are hosting the TFTP server on Windows, you may need to configure Windows firewall to allow <code>‘File and Printer Sharing (Echo Request – ICMPv4 – In)’</code>. This is only needed to test the network connection with <code>ping</code> and not for the actual <code>tftpboot</code> command so if <code>ping</code> fails <code>tftpboot</code> may still succeed.
# ping ${Server IP}
Example:
# ping 192.168.1.228
The result should look something like this:
<pre>
Star64 # ping 192.168.1.199
Using ethernet@16030000 device
host 192.168.1.199 is alive
</pre>
If ping fails, please try again or please join the #star64 channel in the Pine64 IRC, Discord, or Matrix for help.

Finally, it is time to update the xSPI flash.

First, initialize the flash with the <code>sf probe</code> command.
# sf probe
The output should be something like:
<pre>
Star64 # sf probe
SF: Detected gd25lq128 with page size 256 Bytes, erase size 4 KiB, total 16 MiB
</pre>
Next copy the SPL <code>.bin.normal.out</code> file to memory address 0xa0000000 from our TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo spl file]
Where ${serverip} is the environment variable we set earlier, no need to change it.
Then use <code>sf update</code> to erase and update the SPI flash from memory. In this case we are copying from memory address 0xa0000000 which we wrote to earlier with an offset of 0x0.

# sf update 0xa0000000 0x0 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Next, copy the U-Boot <code>.img</code> binary to memory address 0xa0000000 from the TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo uboot image]
Where ${serverip} is the environment variable we set earlier, no need to change it.

Finally, write the new U-Boot binary using <code>sf update</code> from memory address 0xa0000000 with an offset of 0x100000.
# sf update 0xa0000000 0x100000 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Reboot the Star64 and the changes should have taken effect.

User:RemDogKap/SandBox/First Setup

2023-06-17T01:29:33Z

RemDogKap: changed example sections to be collapsible, fixed typos, changed to be filled in things from ${} to <>

{{Under construction}}

The Star64 is a 64 bit, 4 core Single Board Computer.

==Prerequisites==

*[https://pine64.com/product-category/star64/ Star64 SBC]
*[https://pine64.com/product-category/star64-accessories/ 12V 3A to 5A Power Supply] (Any 12V 3A or 5A type M 5.5mm OD/2.1mm ID barrel type DC Jack Power Supply will work)
*One or more types of removeable flash memory
**[https://pine64.com/product/64gb-class10-microsd-card/ SD card] of at least ??GB, no greater than 256GB
**[https://pine64.com/product-category/star64-accessories/ eMMC Module] with [https://pine64.com/product/usb-adapter-for-emmc-module/ USB adapter]
*Ability to flash a storage device with a disk image. [https://etcher.balena.io/ Balena Etcher] is recommended, but advanced users can also use dd in a Unix-like OS

==Choosing Your Distribution==
There are currently two working distributions of Linux compatible with the Star64, pinix and Armbian. Both distributions use the same kernel[???].The pinix distribution is a custom distribution built by Fishwaldo using Yocto which is an open source project used to create Linux distributions for embedded devices. The pinix distribution is currently focusing on support for GPU and VGPU acceleration for desktop environments. Both distributions use the deb package manager. The Armbian distribution is based on Debian/Ubuntu with changes to make it lightweight and compatible with ARM/RISC-V development boards.

While there are other RISC-V compatible distributions, none of these have the required device tree entries for the Star64 meaning that none will work fully on the Star64. This includes images for the StarFive2, a sister board which uses the same processor, due to other hardware differences. It may be possible to get other distributions to run on the Star64 by cross compiling the working kernel into another distribution.

More information about support for features can be accessed [[User:RemDogKap/SandBox/Status of Features | here]].

==pinix==
There are currently three prebuilt versions of pinix. one command line only and two desktop environments. Choose one to use for this setup.
*star64-image-minimal - A command line only image.
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

===Flashing the Image===

====Linux====

First, if not already installed, install <code>bzip2</code> and <code>wget</code>.
$ sudo apt update && sudo apt install bzip2 wget

Second, download a compressed disk image (<code>.wic.bz2</code>) of your chosen version (minimal, weston, or plasma) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) using wget.

$ wget <nowiki>https://pine64.my-ho.st:8443/<Name of Image File></nowiki>

Where <code><Name of Image File></code> is the name of your chosen image file. <span class="mw-customtoggle-if-dl-toggle" style="text-decoration:underline;color:#0645ad">Example</span>

<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-if-dl-toggle">
$ wget <nowiki>https://pine64.my-ho.st:8443/star64-image-minimal-star64-1.2.wic.bz2</nowiki>
</div>

Next, decompress the file using bzip2.

$ bzip2 -d <Path to Image File>

Where <code><Path to Image File></code> is the path to your image file. <span class="mw-customtoggle-if-unzip-toggle" style="text-decoration:underline;color:#0645ad">Example</span>

<div class="mw-collapsible mw-collapsed" id="mw-customcollapsible-if-unzip-toggle">
$ bzip2 -d star64-image-minimal-star64-1.2.wic.bz2
</div>

Next, flash the image to the SD card or eMMC module. The open source Balena Etcher with GUI support is recommended but dd will work as well if you are an advanced user.

====Windows====

First, make sure that you have [https://7-zip.org/ 7zip] installed and if not, install it.

Second, download a compressed disk image (<code>.wic.bz2</code>) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) by clicking on the files.

Third, right click on the downloaded file and select 7-zip. Next click extract.

Finally, use Balena Etcher to write your disk image to the SD Card or eMMC module .

===Booting the Image===

First, make sure that the Star64 is powered off, then set the boot dip switches to SD Card or eMMC, whichever applies to you.

<div><ul>
<li style="display: inline-block;"> [[File:Star64_SD_switch_map.png|thumb|left|Dip switch settings to boot from SD Card.]] </li>
<li style="display: inline-block;"> [[File:Star64_EMMC_switch_map.png|thumb|Dip switch settings to boot from eMMC module.]] </li>
</ul></div>

After that, insert your flash media of choice and connect your peripherals. These can be a keyboard mouse and monitor or a TTL UART cable connected to the GPIO header. Finally, power on the system.

After boot, you should be met with a login screen. The default credentials here for a root user are root as a username and Star64 as a password. The default credentials for a regular user are Star64 as a username and Star64 as a password. If you do not see the troublshooting section below

==Troubeshooting==
{{:STAR64}}

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-13T02:13:21Z

RemDogKap: switched the structure, completed the section on using windows.

{{Under construction}}
{{Warning | Attempting these instructions may permanently brick (make nonfunctional) your device. Do not attempt unless you know what you are doing.}}
{{Warning | These instructions have not been tested or verified. Use at your own risk.}}

The Star64 ships with an integrated 128 megabit (16 megabyte) xSPI NOR flash. Loaded on this flash from the factory is firmware called U-Boot and SPL but an old version designed for the StarFive VisionFive 2 SBC which may have incompatibilities with the Star64. The firmware on this flash is known as Das U-Boot, commonly just U-Boot which is an open-source primary boot loader. It performs similar functions to the BIOS on x86 platforms. The SPL or Secondary Program Loader is the software that loads U-Boot, which in turn loads the Linux kernel.

There are two main ways to update the xSPI flash. The first uses the <code>flashcp</code> command which requires the Star64 to first boot into an OS. This method may not work on older versions of [firmware, os, something else????]. The other method requires only the ability to load U-Boot and uses TFTP and the U-Boot <code>tftpboot</code> command.

==Prerequisites==
Required:
*Star64 SBC
*Computer running Linux, MacOS, or Windows
Possibly required:
*Ability to communicate over TTL (transistor to transistor logic) UART
*Ability to network the Star64 to a computer over ethernet

==flashcp==
First, connect to your Star64 over UART or with a mouse, keyboard, and monitor.
Next, install the <code>mtd-utils</code> package onto the Star64 if not already installed. This package is a set of tools that allow access to raw flash storage devices such as the xSPI flash. Also install <code>wget</code> if not already installed. These instructions assume that you are using the <code>deb</code> package manager.
$ sudo apt update && sudo apt install mtb-utils wget

Next, using <code>wget</code> download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image onto the.
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Next, print out the list of MTD (Memory Technology Device) raw flash devices using <code>cat</code>.
$ cat /proc/mtd

The output should look something like this:
<pre>
dev: size erasesize name
mtd0: 00020000 00001000 "spl"
mtd1: 00300000 00001000 "uboot"
mtd2: 00100000 00001000 "data"
</pre>

Finally, write the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image. to the respective partitions using <code>flashcp</code>, a command which writes to raw flash devices with more protections than <code>dd</code>.
$ flashcp -v [fishwaldo spl file name here].bin.normal.out /dev/${SPL Partition}
$ flashcp -v [fishwaldo uboot img file name here].img /dev/${U-Boot Partition}
Where <code>${SPL Partition}</code> is the partition name found under the "dev" column for the row "spl" from the cat printout, in this case <code>mtd0</code> and <code>${U-Boot Partition}</code> is the partition name found under the "dev" column for the row "uboot" in the cat printout, in this case <code>mtd1</code>.

At this point your xSPI flash has been rewritten and only a system restart is needed for the changes to take effect.

==tftpboot==
The <code>tftpboot</code> method uses a TFTP (Trivial File Transfer Protocol, a protocol which allows for basic file transfer functionality without authentication) server to transfer the SPL file and U-Boot image from a host computer to the Star64 running U-Boot and using the <code>tftpboot</code> command and then written to flash using the <code>sf</code> command which is a U-Boot command used to access SPI flash.

===Preparing The TFTP Server===
====Linux====
First, on your computer (not the Star64) install a TFTP server and <code>wget</code> if you do not already have it.
$ sudo apt update && sudo apt install tftpd-hpa wget
Next, check that the TFPT server is running using <code>systemctl</code>.
$ sudo systemctl status tftpd-hpa
This should output somethng like

<span style="color:#16c60c">●</span> tftpd-hpa.service - LSB: HPA's tftp server
Loaded: loaded (/etc/init.d/tftpd-hpa; generated)
Active: <span style="color:#16c60c">active (running)</span> since Sat 2023-06-10 20:51:28 CDT; 17min ago
Docs: man:systemd-sysv-generator(8)
Process: 1016 ExecStart=/etc/init.d/tftpd-hpa start (code=exited, status=0/SUCCESS)
Tasks: 1 (limit: 2306)
Memory: 588.0K
CPU: 23ms
CGroup: /system.slice/tftpd-hpa.service
└─1023 /usr/sbin/in.tftpd --listen --user tftp --address :69 --secure /srv/tftp

Jun 10 20:51:28 debian-bookworm systemd[1]: Starting tftpd-hpa.service - LSB: HPA's tftp server...
Jun 10 20:51:28 debian-bookworm tftpd-hpa[1016]: Starting HPA's tftpd: in.tftpd.
Jun 10 20:51:28 debian-bookworm systemd[1]: Started tftpd-hpa.service - LSB: HPA's tftp server.

If the service is not running, try
$ sudo systemctl start tftpd-hpa
and check the status again. If it is still not running please join the #star64 channel in the Pine64 IRC, Discord, or Matrix.

Next, edit the configuration file for <code>tftpd-hpa</code>.
$ sudo nano /etc/default/tftpd-hpa
by default it should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/srv/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Change <code>TFTP_DIRECTORY="/srv/tftp"</code> to <code>TFTP_DIRECTORY="/home/user/tftp_share"</code>. The final file should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/home/user/tftp_share"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
After that, save and close the file then restart the TFTP server.
$ sudo systemctl restart tftpd-hpa

Next in your home directory (<code>/home/user</code>) create a folder called <code>tftp_share</code>
$ mkdir /home/user/tftp_share
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image using <code>wget</code>.
$ cd /home/user/tftp_share
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Before connecting to the Star64 and updating the firmware install minicom, virtual console software, so it will be possible to communicate with the Star64.
$ sudo apt update && sudo apt install minicom
Next connect the your USB to TTL UART adapter to the computer and list the connected serial devices.
$ dmesg | grep tty
Example output:
<pre>
to be
filled in
later
</pre>
Find the address of the TTL UART to USB adapter in the list (example: <code>ttyUSB0</code>) and connect to the serial device with a baud rate of 115200.
$ sudo minicom -D /dev/${Device Address} -b 115200
Where ${Device Address} is the address found in the step above. Example:
$ sudo minicom -D /dev/ttyUSB0 -b 115200

====Windows====

First, install two pieces of software, [https://pjo2.github.io/tftpd64/ tftpd64], a TFTP server for windows, and [http://ttssh2.osdn.jp/index.html.en Tera Term], a virtual console for interacting with the Star64 in U-Boot.
Next on your desktop, create a folder called <code>tftp_share</code>
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image from [https://pine64.my-ho.st:8443/ here]

Next, load tftpd64 and configure the settings to have the "Current Directory" as the <code>tftp_share</code> folder on the desktop and "Server interfaces" is set to <code>127.0.0.1 Software Loopback Interface 1</code>. The path should look something like <code>C:\Users\${Username}\Desktop\tftp_share</code> where <code>${Username}</code> is your username on Windows.
[[File:Star64 tftpd64 settings.png|none|500px|thumb|left]]

===Updating the SPI Flash===

Next, connect a TTL UART to USB cable to to the Star64 with the GND cable on pin 6 of the GPIO header, TXD on pin 8, and RXD on pin 10 as well as ethernet. Note that depending on your UART adapter you may have to switch TXD and RXD. Now power on the Star64 and enter U-Boot. You will need to press a key to prevent it from autobooting and instead enter the U-Boot command prompt.
Once you are in the U-Boot shell set some environment variables.
First, set the IP address of the Star64 and connect it to the network using the <code>dhcp</code> command.
# dhcp

Ping the TFTP server from the Star64 to make sure the connection works where <code>${Server IP}</code> refers to the IP address of your TFTP server. If you don't what the IP address of your TFTP server is you can see connected devices in your router's configuration which can usually be accessed by typing in the IP address found on the router itself. Note that if you are hosting the TFTP server on Windows, you may need to configure Windows firewall to allow <code>‘File and Printer Sharing (Echo Request – ICMPv4 – In)’</code>. This is only needed to test the network connection with <code>ping</code> and not for the actual <code>tftpboot</code> command so if <code>ping</code> fails <code>tftpboot</code> may still succeed.
# ping ${Server IP}
Example:
# ping 192.168.1.228
The result should look something like this:
<pre>
Star64 # ping 192.168.1.199
Using ethernet@16030000 device
host 192.168.1.199 is alive
</pre>
If ping fails, please try again or please join the #star64 channel in the Pine64 IRC, Discord, or Matrix for help.

Finally, it is time to update the xSPI flash.

First, initialize the flash with the <code>sf probe</code> command.
# sf probe
The output should be something like:
<pre>
Star64 # sf probe
SF: Detected gd25lq128 with page size 256 Bytes, erase size 4 KiB, total 16 MiB
</pre>
Next copy the SPL <code>.bin.normal.out</code> file to memory address 0xa0000000 from our TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo spl file]
Where ${serverip} is the environment variable we set earlier, no need to change it.
Then use <code>sf update</code> to erase and update the SPI flash from memory. In this case we are copying from memory address 0xa0000000 which we wrote to earlier with an offset of 0x0. [what is $filesize???? does the user need to replace it, will it just work?????]

# sf update 0xa0000000 0x0 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Next, copy the U-Boot <code>.img</code> binary to memory address 0xa0000000 from the TFTP server.
# tftpboot 0xa0000000 ${serverip}:[name of fishwaldo uboot image]
Where ${serverip} is the environment variable we set earlier, no need to change it.

Finally, write the new U-Boot binary using <code>sf update</code> from memory address 0xa0000000 with an offset of 0x100000. [what is $filesize???? does the user need to replace it, will it just work?????]
# sf update 0xa0000000 0x100000 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Reboot the Star64 and the changes should have taken effect.

File:Star64 tftpd64 settings.png

2023-06-13T01:22:38Z

RemDogKap: screenshot of settings for tftpd64 server on windows to flash U-Boot to Star64

== Summary ==
screenshot of settings for tftpd64 server on windows to flash U-Boot to Star64
== Licensing ==
{{PD|PD}}

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-13T00:06:06Z

RemDogKap: minor syntax and grammar edits, introduced section on setting up minicom

{{Under construction}}
{{Warning | Attempting these instructions may permanently brick (make nonfunctional) your device. Do not attempt unless you know what you are doing.}}
{{Warning | These instructions have not been tested or verified. Use at your own risk.}}

The Star64 ships with an integrated 128 megabit (16 megabyte) xSPI NOR flash. Loaded on this flash from the factory is firmware called U-Boot and SPL but an old version designed for the StarFive VisionFive 2 SBC which may have incompatibilities with the Star64. The firmware on this flash is known as Das U-Boot, commonly just U-Boot which is an open-source primary boot loader. It performs similar functions to the BIOS on x86 platforms. The SPL or Secondary Program Loader is the software that loads U-Boot, which in turn loads the Linux kernel.

There are two main ways to update the xSPI flash. The first uses the <code>flashcp</code> command which requires the Star64 to first boot into an OS. This method may not work on older versions of [firmware, os, something else????]. The other method requires only the ability to load U-Boot and uses TFTP and the U-Boot <code>tftpboot</code> command.

==Prerequisites==
Required:
*Star64 SBC
*Computer running Linux, MacOS, or Windows
Possibly required:
*Ability to communicate over TTL (transistor to transistor logic) UART
*Ability to network the Star64 to a computer over ethernet

==flashcp==
First, connect to your Star64 over UART or with a mouse, keyboard, and monitor.
Next, install the <code>mtd-utils</code> package onto the Star64 if not already installed. This package is a set of tools that allow access to raw flash storage devices such as the xSPI flash. Also install <code>wget</code> if not already installed. These instructions assume that you are using the <code>deb</code> package manager.
$ sudo apt update && sudo apt install mtb-utils wget

Next, using <code>wget</code> download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image onto the.
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Next, print out the list of MTD (Memory Technology Device) raw flash devices using <code>cat</code>.
$ cat /proc/mtd

The output should look something like this:
<pre>
dev: size erasesize name
mtd0: 00020000 00001000 "spl"
mtd1: 00300000 00001000 "uboot"
mtd2: 00100000 00001000 "data"
</pre>

Finally, write the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image. to the respective partitions using <code>flashcp</code>, a command which writes to raw flash devices with more protections than <code>dd</code>.
$ flashcp -v [fishwaldo spl file name here].bin.normal.out /dev/${SPL Partition}
$ flashcp -v [fishwaldo uboot img file name here].img /dev/${U-Boot Partition}
Where <code>${SPL Partition}</code> is the partition name found under the "dev" column for the row "spl" from the cat printout, in this case <code>mtd0</code> and <code>${U-Boot Partition}</code> is the partition name found under the "dev" column for the row "uboot" in the cat printout, in this case <code>mtd1</code>.

At this point your xSPI flash has been rewritten and only a system restart is needed for the changes to take effect.

==tftpboot==
The <code>tftpboot</code> method uses a TFTP (Trivial File Transfer Protocol, a protocol which allows for basic file transfer functionality without authentication) server to transfer the SPL file and U-Boot image from a host computer to the Star64 running U-Boot and using the <code>tftpboot</code> command and then written to flash using the <code>sf</code> command which is a U-Boot command used to access SPI flash.

===Linux===
First, on your computer (not the Star64) install a TFTP server and <code>wget</code> if you do not already have it.
$ sudo apt update && sudo apt install tftpd-hpa wget
Next, check that the TFPT server is running using <code>systemctl</code>.
$ sudo systemctl status tftpd-hpa
This should output somethng like

<span style="color:#16c60c">●</span> tftpd-hpa.service - LSB: HPA's tftp server
Loaded: loaded (/etc/init.d/tftpd-hpa; generated)
Active: <span style="color:#16c60c">active (running)</span> since Sat 2023-06-10 20:51:28 CDT; 17min ago
Docs: man:systemd-sysv-generator(8)
Process: 1016 ExecStart=/etc/init.d/tftpd-hpa start (code=exited, status=0/SUCCESS)
Tasks: 1 (limit: 2306)
Memory: 588.0K
CPU: 23ms
CGroup: /system.slice/tftpd-hpa.service
└─1023 /usr/sbin/in.tftpd --listen --user tftp --address :69 --secure /srv/tftp

Jun 10 20:51:28 debian-bookworm systemd[1]: Starting tftpd-hpa.service - LSB: HPA's tftp server...
Jun 10 20:51:28 debian-bookworm tftpd-hpa[1016]: Starting HPA's tftpd: in.tftpd.
Jun 10 20:51:28 debian-bookworm systemd[1]: Started tftpd-hpa.service - LSB: HPA's tftp server.

If the service is not running, try
$ sudo systemctl start tftpd-hpa
and check the status again. If it is still not running please join the #star64 channel in the Pine64 IRC, Discord, or Matrix.

Next, edit the configuration file for <code>tftpd-hpa</code>.
$ sudo nano /etc/default/tftpd-hpa
by default it should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/srv/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Change <code>TFTP_DIRECTORY="/srv/tftp"</code> to <code>TFTP_DIRECTORY="/home/user/tftp_share"</code>. The final file should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/home/user/tftp_share"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
After that, save and close the file then restart the TFTP server.
$ sudo systemctl restart tftpd-hpa

Next in your home directory (<code>/home/user</code>) create a folder called <code>tftp_share</code>
$ mkdir /home/user/tftp_share
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image using <code>wget</code>.
$ cd /home/user/tftp_share
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Before connecting to the Star64 and updating the firmware set up minicom, a virtual console software, so it will be possible to communicate with the Star64.

First install minicom.
$ sudo apt update && sudo apt install minicom
Next connect the your USB to TTL UART adapter to the computer and list the connected serial devices.
$ dmesg |grep tty
Example output:
<pre>
to be
filled in
later
</pre>
Find the address of the adapter in the list (example: <code>ttyUSB0</code>) and connect to the serial device with a baud rate of 115200.
$ sudo minicom -D /dev/${Device Address} -b 115200
Where ${Device Address} is the address found in the step above. Example:
$ sudo minicom -D /dev/ttyUSB0 -b 115200

Next, connect a TTL UART to USB cable to to the Star64 with the GND cable on pin 6 of the GPIO header, TXD on pin 8, and RXD on pin 10. Note that depending on your UART adapter you may have to switch TXD and RXD. Now power on the Star64 and enter U-Boot. You will need to press a key to prevent it from autobooting and instead enter the U-Boot command prompt.
Once you are in the U-Boot shell set some environment variables.
First, set the IP address of your Star64 where <code>${IP Address}</code> is the IP address you have chosen.
$ setenv ipaddr ${IP Address}
An example IP address would be:
$ setenv ipaddr 192.168.1.158
Next set the IP address of your TFTP server. If you don't what the IP address of your TFTP server is you can see connected devices in your router configuration which can usually be accessed by typing in the IP address found on the router itself. In this case <code>${Server IP}</code> refers to the IP address of your TFTP server.
# setenv serverip ${Server IP}
An example would be:
$ setenv serverip 192.168.1.228
Note that it is important that the first three sets of numbers (in the examples <code>192.168.1</code>) must be the same for your Star64, router, and TFTP server. The numbers may not be the same as in the example.
Ping the TFTP server from the Star64 to make sure the connection works where <code>${Server IP}</code> refers to the IP address of your TFTP server.
$ ping ${Server IP}
Example:
$ ping 192.168.1.228
The result should look something like this:
<pre>
To be
filled
in later
</pre>
If ping fails, please try again or please join the #star64 channel in the Pine64 IRC, Discord, or Matrix for help.

Finally, it is time to update the xSPI flash.

First, initialize the flash with the <code>sf probe</code> command.
$ sf probe
The output should be something like:
<pre>
To be
filled
in later
</pre>
Next copy the SPL <code>.bin.normal.out</code> file to memory address 0xa0000000 from our TFTP server.
$ tftpboot 0xa0000000 ${serverip}:[name of fishwaldo spl file]
Where ${serverip} is the environment variable we set earlier, no need to change it.
Then use <code>sf update</code> to erase and update the SPI flash from memory. In this case we are copying from memory address 0xa0000000 which we wrote to earlier with an offset of 0x0. [what is $filesize???? does the user need to replace it, will it just work?????]

$ sf update 0xa0000000 0x0 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Next, copy the U-Boot <code>.img</code> binary to memory address 0xa0000000 from the TFTP server.
$ tftpboot 0xa0000000 ${serverip}:[name of fishwaldo uboot image]
Where ${serverip} is the environment variable we set earlier, no need to change it.

Finally, write the new U-Boot binary using <code>sf update</code> from memory address 0xa0000000 with an offset of 0x100000. [what is $filesize???? does the user need to replace it, will it just work?????]
$ sf update 0xa0000000 0x100000 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Reboot the Star64 and the changes should have taken effect.

===Windows===

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-11T03:32:04Z

RemDogKap: Finished initial writing of tftpboot linux instructions

{{Under construction}}
{{Warning | Attempting these instructions may permanently brick (make nonfunctional) your device. Do not attempt unless you know what you are doing.}}
{{Warning | These instructions have not been tested or verified. Use at your own risk.}}

The Star64 ships with an integrated 128 megabit (16 megabyte) xSPI NOR flash. Loaded on this flash from the factory is firmware called U-Boot and SPL but an old version designed for the StarFive VisionFive 2 SBC which may have incompatibilities with the Star64. The firmware on this flash is known as Das U-Boot, commonly just U-Boot which is an open-source primary boot loader. It performs similar functions to the BIOS on x86 platforms. The SPL or Secondary Program Loader is the software that loads U-Boot, which in turn loads the Linux kernel.

There are two main ways to update the xSPI flash. The first uses the <code>flashcp</code> command which requires the Star64 to first boot into an OS. This method may not work on older versions of [firmware, os, something else????]. The other method requires only the ability to load U-Boot and uses TFTP and the U-Boot <code>tftpboot</code> command.

==Prerequisites==
Required:
*Star64 SBC
*Computer running Linux, MacOS, or Windows
Possibly required:
*Ability to communicate over TTL (transistor to transistor logic) UART
*Ability to network the Star64 to a computer over ethernet

==flashcp==
First, connect to your Star64 over UART or with a mouse, keyboard, and monitor.
Next, install the <code>mtd-utils</code> package onto the Star64 if not already installed. This package is a set of tools that allow access to raw flash storage devices such as the xSPI flash. Also install <code>wget</code> if not already installed. These instructions assume that you are using the <code>deb</code> package manager.
$ sudo apt update && sudo apt install mtb-utils wget

Next, using <code>wget</code> download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image onto the.
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Next, print out the list of MTD (Memory Technology Device) raw flash devices using <code>cat</code>.
$ cat /proc/mtd

The output should look something like this:
<pre>
dev: size erasesize name
mtd0: 00020000 00001000 "spl"
mtd1: 00300000 00001000 "uboot"
mtd2: 00100000 00001000 "data"
</pre>

Finally, write the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image. to the respective partitions using <code>flashcp</code>, a command which writes to raw flash devices with more protections than <code>dd</code>.
$ flashcp -v [fishwaldo spl file name here].bin.normal.out /dev/${SPL Partition}
$ flashcp -v [fishwaldo uboot img file name here].img /dev/${U-Boot Partition}
Where <code>${SPL Partition}</code> is the partition name found under the "dev" column for the row "spl" from the cat printout, in this case <code>mtd0</code> and <code>${U-Boot Partition}</code> is the partition name found under the "dev" column for the row "uboot" in the cat printout, in this case <code>mtd1</code>

At this point your xSPI flash has been rewritten and only a system restart is needed for the changes to take effect.

==tftpboot==
The <code>tftpboot</code> method uses a TFTP (Trivial File Transfer Protocol, a protocol which allows for basic file transfer functionality without authentication) server to transfer the SPL file and U-Boot image from a host computer to the Star64 running U-Boot and using the <code>tftpboot</code> command and then written to flash using the <code>sf</code> command which is a U-Boot command used to access SPI flash.

===Linux===
First, on your computer (not the Star64) install a TFTP server and <code>wget</code> if you do not already have it.
$ sudo apt update && sudo apt install tftpd-hpa wget
Next, check that the TFPT server is running using <code>systemctl</code>.
$ sudo systemctl status tftpd-hpa
This should output somethng like

<span style="color:#16c60c">●</span> tftpd-hpa.service - LSB: HPA's tftp server
Loaded: loaded (/etc/init.d/tftpd-hpa; generated)
Active: <span style="color:#16c60c">active (running)</span> since Sat 2023-06-10 20:51:28 CDT; 17min ago
Docs: man:systemd-sysv-generator(8)
Process: 1016 ExecStart=/etc/init.d/tftpd-hpa start (code=exited, status=0/SUCCESS)
Tasks: 1 (limit: 2306)
Memory: 588.0K
CPU: 23ms
CGroup: /system.slice/tftpd-hpa.service
└─1023 /usr/sbin/in.tftpd --listen --user tftp --address :69 --secure /srv/tftp

Jun 10 20:51:28 debian-bookworm systemd[1]: Starting tftpd-hpa.service - LSB: HPA's tftp server...
Jun 10 20:51:28 debian-bookworm tftpd-hpa[1016]: Starting HPA's tftpd: in.tftpd.
Jun 10 20:51:28 debian-bookworm systemd[1]: Started tftpd-hpa.service - LSB: HPA's tftp server.

If the service is not running, try
$ sudo systemctl start tftpd-hpa
and check the status again. If it is still not running please join the #star64 channel in the Pine64 IRC, Discord, or Matrix.

Next, edit the configuration file for <code>tftpd-hpa</code>.
$ sudo nano /etc/default/tftpd-hpa
by default it should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/srv/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
Change <code>TFTP_DIRECTORY="/srv/tftp"</code> to <code>TFTP_DIRECTORY="/home/user/tftp_share"</code>. The final file should look like:
<pre>
TFTP_USERNAME="tftp"
TFTP_DIRECTORY="/home/user/tftp_share"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"
</pre>
After that, save and close the file then restart the TFTP server.
$ sudo systemctl restart tftpd-hpa

Next in your home directory (<code>/home/user</code>) create a folder called <code>tftp_share</code>
$ mkdir /home/user/tftp_share
In this folder, download the <code>.bin.normal.out</code> SPL file and the <code>.img</code> U-Boot image using <code>wget</code>.
$ cd /home/user/tftp_share
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo SPL file goes here]</nowiki>
$ wget <nowiki>https://pine64.my-ho.st:8443/[fishwaldo U-Boot image goes here]</nowiki>

Now power on the Star64 and enter U-Boot. You may need to [press shift??? press any key????] during boot to enter U-Boot.
Once you are in the U-Boot shell set some environment variables.
First, set the IP address of your Star64 where <code>${IP Address}</code> is the IP address you have chosen.
$ setenv ipaddr ${IP Address}
An example IP address would be
$ setenv ipaddr 192.168.1.158
Next set the IP address of your TFTP server. If you don't what the IP address of your TFTP server is you can see connected devices in your router configuration which can usually be accessed by typing in the IP address found on the router itself. In this case <code>${Server IP}</code> refers to the IP address of your TFTP server.
# setenv serverip ${Server IP}
An example would be
$ setenv serverip 192.168.1.228
Note that it is important that the first three sets of numbers (in the examples <code>192.168.1</code>) must be the same for your Star64 router, and TFTP server. The numbers may not be the same as in the example.
Ping the TFTP server from the Star64 to make sure the connection works where <code>${Server IP}</code> refers to the IP address of your TFTP server.
$ ping ${Server IP}
Example:
$ ping 192.168.1.228
The result should look something like this:
<pre>
To be
filled
in later
</pre>
If ping fails, please try again or please join the #star64 channel in the Pine64 IRC, Discord, or Matrix for help.

Finally, it is time to update the xSPI flash.

First, initialize the flash with the <code>sf probe</code> command.
$ sf probe
The output should be something like:
<pre>
To be
filled
in later
</pre>
Next copy the SPL <code>.bin.normal.out</code> file to memory address 0xa0000000 from our TFTP server.
$ tftpboot 0xa0000000 ${serverip}:[name of fishwaldo spl file]
Where ${serverip} is the environment variable we set earlier, no need to change it.
Then use <code>sf update</code> to erase and update the SPI flash from memory. In this case we are copying from memory address 0xa0000000 which we wrote to earlier with an offset of 0x0. [what is $filesize???? does the user need to replace it, will it just work?????]

$ sf update 0xa0000000 0x0 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Next, copy the U-Boot <code>.img</code> binary to memory address 0xa0000000 from the TFTP server.
$ tftpboot 0xa0000000 ${serverip}:[name of fishwaldo uboot image]
Where ${serverip} is the environment variable we set earlier, no need to change it.

Finally, write the new U-Boot binary using <code>sf update</code> from memory address 0xa0000000 with an offset of 0x100000. [what is $filesize???? does the user need to replace it, will it just work?????]
$ sf update 0xa0000000 0x100000 $filesize

This should produce an output like:
<pre>
To be
filled
in later
</pre>

Reboot the Star64 and the changes should have taken effect.

===Windows===

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-11T02:36:29Z

RemDogKap: minor edits and how to install and set up TFTP server

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-10T05:21:11Z

RemDogKap: minor grammar updates, started on updating Star64 firmware using tftpboot on Linux.

User:RemDogKap/SandBox/Update XSPI Flash SPL and U-Boot

2023-06-10T04:51:27Z

RemDogKap: initial rough out and instruction for the flashcp method of updating Star64 firmware

User:RemDogKap/SandBox

2023-06-10T03:36:22Z

RemDogKap: added page on how to update XSPI Flash of Star64

User:RemDogKap/SandBox/Build Your Own Image

2023-06-10T01:11:01Z

RemDogKap: initial rough out

{{Under construction}}

==Things you need to do to build your own image==
*crosscompile fishwaldo kernel with your distro [https://forum.pine64.org/showthread.php?tid=18276]
*if you want gpu acceleration you need a kernel driver and userspace patches [https://forum.pine64.org/showthread.php?tid=18301]
*must have two partitions to boot, SPL and U-Boot
*patch system memory ?? [https://forum.pine64.org/showthread.php?tid=18263]
*patch USB overvoltage ??

User:RemDogKap/SandBox

2023-06-10T00:55:09Z

RemDogKap: added build your own image page and under construction tag

User:RemDogKap/SandBox/First Setup

2023-06-10T00:51:23Z

RemDogKap: Added troubleshooting section, booting section, and restructured the article

{{Under construction}}

The Star64 is a 64 bit, 4 core Single Board Computer.

==Prerequisites==

*[https://pine64.com/product-category/star64/ Star64 SBC]
*[https://pine64.com/product-category/star64-accessories/ 12V 3A to 5A Power Supply] (Any 12V 3A or 5A type M 5.5mm OD/2.1mm ID barrel type DC Jack Power Supply will work)
*One or more types of removeable flash memory
**[https://pine64.com/product/64gb-class10-microsd-card/ SD card] of at least ??GB, no greater than 256GB
**[https://pine64.com/product-category/star64-accessories/ eMMC Module] with [https://pine64.com/product/usb-adapter-for-emmc-module/ USB adapter]
*Ability to flash a storage device with a disk image. [https://etcher.balena.io/ Balena Etcher] is recommended, but advanced users can also use dd in a Unix-like OS

==Choosing Your Distribution==
There are currently two working distributions of Linux compatible with the Star64, pinix and Armbian. Both distributions use the same kernel[???].The pinix distribution is a custom distribution built by Fishwaldo using Yocto which is an open source project used to create Linux distributions for embedded devices. The pinix distribution is currently focusing on support for GPU and VGPU acceleration for desktop environments. Both distributions use the deb package manager. The Armbian distribution is based on Debian/Ubuntu with changes to make it lightweight and compatible with ARM/RISC-V development boards.

While there are other RISC-V compatible distributions, none of these have the required device tree entries for the Star64 meaning that none will work fully on the Star64. This includes images for the StarFive2, a sister board which uses the same processor, due to other hardware differences. It may be possible to get other distributions to run on the Star64 by cross compiling the working kernel into another distribution.

More information about support for features can be accessed [[User:RemDogKap/SandBox/Status of Features | here]].

==pinix==
There are currently three prebuilt versions of pinix. one command line only and two desktop environments. Choose one to use for this setup.
*star64-image-minimal - A command line only image.
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

===Flashing the Image===

====Linux====

First, if not already installed, install <code>bzip2</code> and <code>wget</code>.
$ sudo apt update && sudo apt install bzip2 wget

Second, download a compressed disk image (.wic.bz2) of your chosen verison (minimal, weston, or plasma) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) using wget.

$ wget <nowiki>https://pine64.my-ho.st:8443/${Name of Image File}</nowiki>

Where <code>${Name of Image File}</code> is the name of your chosen image file.
Example:

$ wget <nowiki>https://pine64.my-ho.st:8443/star64-image-minimal-star64-1.2.wic.bz2</nowiki>

Next, decompress the file using bzip2.

$ bzip2 -d ${Path to Image File}

Where <code>${Path to Image File}</code> is the path to your image file. Example:

$ bzip2 -d star64-image-minimal-star64-1.2.wic.bz2

Next, flash the image to the SD card or eMMC module. The open source Balena Etcher with GUI support is recommended but dd will work as well if you are an advanced user.

====Windows====

First, make sure that you have [https://7-zip.org/ 7zip] installed and if not, install it.

Second, download a compressed disk image (.wic.bz2) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) by clicking on the files.

Third, right click on the downloaded file and select 7-zip. Next click extract.

Finally, use Balena Etcher to write your disk image to the SD Card or eMMC module .

===Booting the Image===

{{warning | This has not been fully tested and verified, use these instructions at your own risk, please remove if these look good}}

First, make sure that the Star64 is powered off, then set the boot dip switches to SD Card or eMMC, whichever applies to you.

<div><ul>
<li style="display: inline-block;"> [[File:Star64_SD_switch_map.png|thumb|left|Dip switch settings to boot from SD Card.]] </li>
<li style="display: inline-block;"> [[File:Star64_EMMC_switch_map.png|thumb|Dip switch settings to boot from eMMC module.]] </li>
</ul></div>

After that, insert your flash media of choice and connect your peripherals. These can be a keyboard mouse and monitor or a TTL UART cable connected to the GPIO header. Finally, power on the system.

After boot, you should be met with a login screen. The default credentials here for a root user are root as a username and Star64 as a password. The default credentials for a regular user are Star64 as a username and Star64 as a password. If you do not see the troublshooting section below

==Troubeshooting==
{{:STAR64}}

STAR64

2023-06-10T00:50:14Z

RemDogKap: added <onlyinclude> to potential issues section

[[File:Star64.jpg|400px|thumb|right|The STAR64]]

The '''Star64''' is a RISC-V based Single Board Computer powered by StarFive JH7110 Quad-Core SiFive U74 64-Bit CPU, Imagination Technology BX-4-32 GPU and supports up to 8GB 1866MHz LPDDR4 memory. It provides an eMMC module socket, MicroSD Card slot, PCI-e, Pi-2 Bus, USB 3.0, and many other peripheral interfaces for makers to integrate with sensors and other devices.

[[File:RISC-V.png|600px|]]

== Software releases ==

The releases are still in '''alpha''' state and are only fit for testing purposes.

* [https://github.com/Fishwaldo/meta-pine64 A Set of Images built with Yocto for commandline, weston and plasma - Where possible, GPU/VPU acceleration is enabled.]
* [https://forum.pine64.org/showthread.php?tid=18276 Armbian]

== SoC and Memory Specification ==
* Based on [https://www.starfivetech.com/en/site/soc StarFive JH7110]
[[File:StarFive.jpg|right]]
[[File:JH7110_Block_Diagram.png|800px]]

=== CPU Architecture ===
* [https://www.sifive.com/cores/u74 Quad-core U74 up to 1.5GHz CPU]
[[File:SiFive.jpg|right|200px]]
* Fully compliant with the RISC-V ISA specification
* 64-bit RISC-V Application Core
* 32KB L1 I-cache with ECC
* 32KB L1 D-cache with ECC
* 8 Region Physical Memory Protection
* Virtual Memory support with up to 47 Physical Address bits
* Integrated up to 2MB L2 Cache with ECC
* includes RV64IMAC S7 monitor core, 16 KB L1 I-Cache with ECC, 8 KB DTIM with ECC
* 32-bit RISC-V CPU core (E24) for real time control, support RV32IMFC RISC-V ISA

=== GPU Architecture ===
* [https://www.imaginationtech.com/product/img-bxe-4-32-mc4/ Imagination Technology BXE-4-32 up to 600Mhz GPU]
[[File:imgtech.png|right|200px]]
* Support OpenCL 3.0
* Support OpenGL ES 3.2
* Support Vulkan 1.2
* Tile-based deferred rendering architecture for 3D graphics workloads, with concurrent processing of multiple tiles
* Support for GPU visualization, up to 8 virtual GPUs
* On fly frame buffer compression and decompression (TFBC) algorithm
* Performance: 128 FP32 FLOPs/Clock, 256 FP16 FLOPs/Clock

=== System Memory ===
* LPDDR4 RAM Memory Variants: 2GB, 4GB and 8GB.

== Board Features ==

=== Video ===
* Digital Video output up to 4K@30Hz
* 4K HDR @ 60fps
* H.264/AVC Base/Main/High/High10 profile @ level 5.1; up to 4K×2K @ 60fps
* H.265/HEVC Main/Main10 profile @ level 5.1 High-tier; up to 4K×2K @ 60fps

=== Audio ===
* 3.5mm audio Jack

=== Network ===
* Single or Dual 10/100/1000Mbps Ethernet
* 2.4GHz/5Ghz MIMO WiFi 802.11 b/g/n/ac with Bluetooth 5.2

=== Storage ===
* on-board 128Mbit (16MByte) XSPI NOR flash memory - bootable
* microSD - bootable, supports SDHC and SDXC and storage up to 256GB
* eMMC - bootable (optional eMMC Module)
* 1× USB3.0 Dedicated Host port
* 3× USB2.0 Host port

=== Expansion Ports ===
* PCIe 2.0 ×1 lane
* 2×20 pins "Pi2" GPIO Header
** The JH7110 SoC supports full multiplexing of its GPIO pins. This means any non-power/ground pin can be configured to any function outlined in Table 4-2 of the SoC datasheet.
* 4 lane MiPi DSI port for LCD panel
* 4 lane MiPi CSI port for camera module

== Board Information, Schematics and Certifications ==
* Model "A" Baseboard Dimensions: 133mm×80mm×19mm
* Input Power: DC 12V @ 3A 5.5mmOD/2.1mmID center-positive Barrel DC Jack connector
* Schematic:
** [https://files.pine64.org/doc/star64/Star64_Schematic_V1.1_20230504.pdf STAR64 Schematic 20230504 v1.1 (Production Released version)]
** [https://files.pine64.org/doc/star64/Star64_Schematic_V1.0_20220721.pdf STAR64 Schematic 20220721 v1.0 (Prototype Board)]
* Certifications:
** Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary. However, PINE64 still submits the SBC for FCC, CE, and ROHS certifications and obtain the certificates to prove that the SBC board can pass the testing. Please note, a final commercial product needs to perform its own testing and obtain its own certificate.
** Not yet available

== Datasheets for Components and Peripherals ==
* Star64 JH7110 SoC information:
** [https://doc-en.rvspace.org/JH7110/PDF/JH7110_Product_Brief.pdf StarFive JH7110 SoC Product Brief]
** [https://doc-en.rvspace.org/JH7110/PDF/JH7110_Datasheet.pdf StarFive JH7110 SoC Datasheet]
** [https://doc-en.rvspace.org/JH7110/TRM/ StarFive JH7110 SoC Technical Reference Manual]
* X-Power PMU information:
** [https://files.pine64.org/doc/datasheet/star64/AXP15060%20datasheet%20V0.1.pdf X-Power AXP15060 Datasheet V0.1]
* LPDDR4 (200 Balls) SDRAM:
** [https://files.pine64.org/doc/datasheet/rockpro64/SM512M32Z01MD2BNP(200BALL).pdf Micron LPDDR4 Mobile LPDDR4 Datasheet]
* eMMC information:
** [https://files.pine64.org/doc/rock64/PINE64_eMMC_Module_20170719.pdf PINE64 eMMC module schematic]
** [https://files.pine64.org/doc/rock64/usb%20emmc%20module%20adapter%20v2.pdf PINE64 USB adapter for eMMC module V2 schematic]
** [https://files.pine64.org/doc/rock64/USB%20adapter%20for%20eMMC%20module%20PCB.tar PINE64 USB adapter for eMMC module PCB in JPEG]
** [https://files.pine64.org/doc/datasheet/pine64/E-00517%20FORESEE_eMMC_NCEMAM8B-16G%20SPEC.pdf 16GB Foresee eMMC Datasheet]
** [https://files.pine64.org/doc/datasheet/pine64/SDINADF4-16-128GB-H%20data%20sheet%20v1.13.pdf 32GB/64GB/128GB SanDisk eMMC Datasheet]
* SPI NOR Flash information:
** [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* Ethernet related info:
** TBA
* WiFi/BT module info:
** [https://files.pine64.org/doc/datasheet/star64/Fn-Link_6252B-UUB_datasheet_V1.1_20220329.pdf Fn-Link 6252B 11AC Dual Band 2T2R WiFi + Bluetooth5.2 Datasheet]

== Bringup Notes ==

# The USB over-current protection is not wired up correctly to the USB ports on Star64. The default Starfive Kernel will disable USB on boot as it belives the ports are overcurrent. This ugly hack works around it: https://github.com/Fishwaldo/Star64_linux/commit/2634a13ecfa1fa5c232ec2b9f6a6b6b0d9d66898
# The Wifi Chip (RTL8852BU) is not supported in the kernel. There is a Vendor Driver that is imported in the kernel at https://github.com/Fishwaldo/Star64_linux/tree/Star64_devel/drivers/staging/rtl8852bu but it really needs a cleanup. It does BUG_ON at boot, but wifi is confirmed working.
# HDMI can be finicky. 4K Monitors are known to have a issue. This is also relevant for VisionFive2
# Some kernels/distributions do not detect the total memory correctly. This is due to the way u-boot is configured. Currently, u-boot reads the memory from the eeprom on the Star64, and updates the dtb file before booting the kernel. Distributions that boot differently may not get the updated dtb file with the correct memory entry. You can work around this by recompiling the DTB with the correct memory for your board
# VisionFive2 Kernels will only offer limited functionality on the Star64 - Mainly USB, Wifi and PCI will not work.
# The 4-pin 12 volt JST-XH-4A connector found on the Star64 is incompatible with the dual SATA power adapter intended for the ROCKPro64. The connector on the Star64 is rotated 180 degrees to the one on the ROCKPro64, resulting in the cable receiving +12V where GND is expected and vice versa. The cable's internal circuitry ends up shorting in this configuration.

== Potential Issues ==
<onlyinclude>
If you get the following error in u-boot (or your 8Gb board is only detected as 4Gb) the possible problem is a empty, or corrupt eeprom:
<pre>
Not a StarFive EEPROM data format - magic error
EEPROM dump: (0x100 bytes)
00: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
10: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
20: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
30: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
40: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
50: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
60: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
70: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
80: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
90: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
A0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
B0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
C0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
D0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
E0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
F0: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
</pre>
Then from within u-boot execute the following commands:
<pre>
mac initilize
mac product_id <PRODUCTID>
mac write_eeprom
</pre>

Set ProductID to either:
* For 8Gb Models: STAR64V1-2310-D008E000-01234567
* for 4Gb Models: STAR64V1-2310-D004E000-01234567

You can replace the last 8 digits with a random number if you wish.
If these commands fail, please join the #star64 channel in the Pine64 community for more assistance.
</onlyinclude>
== Prototype Bringup Notes ==

Note: This section is relevant to the original prototype (v1.0) that a few developers received.

# The [https://files.pine64.org/doc/star64/Star64_Schematic_V1.0_20220721.pdf schematic] has several discrepancies with actual board labels.
# The serial console can be found with TXD on pin 8 and RXD on pin 10; a convention common to Pi-style boards. Use the 40pin header pinouts in color on page one and not the schematic prose.
# If you have only a single core running and no PCI card present, it appears to power up via the +5V/GND lines from the USB serial adapter pins.
# It will not boot from a VisionFive R1 uSD card.
# The boot device switch labels and the silk screen are inverted. "0" means "On".
# 2021.10-00001-gdbdaad919b will attempt to boot from SPI, but it appears blank. If you let it for many minutes, the device will eventually time out and boot OpenSBI v1.0 from (SPI?). This will fail, but only after self-identifying as a VisionFive R2, complete with five cores and 4 GB of RAM, before failing. A "press any key" timeout is offered, but I've been unable to make it stop. It will eventually crash with:

Loading Environment from SPIFlash... SF: Detected gd25lq128 with page size 256 Bytes, erase size 4 KiB, total 16 MiB
*** Warning - bad CRC, using default environment

Not a StarFive EEPROM data format - magic error

[[Category:STAR64]] [[Category:StarFive JH7110]]

User:RemDogKap/SandBox

2023-06-10T00:39:10Z

RemDogKap: added todo for connecting over serial

Links to documentation pages I am currently working on for the Star64 SBC

ToDo:
*Explain that SD Card does not work at full speed
*Tutorial for loading disk images onto eMMC
*How to update XSPI U-Boot
*How to use NVME drives
*working state of various USB ports
*list hardware bugs
**SD Card Voltage
**USB over current
*Armbian Install
*Memory DTB fix/recompile eeprom thing
*How to flash eMMC from SD card if possible
*Things needed to build you own working image
*How to connect over serial

[[/First Setup]]

[[/Storage Formats]]

[[/Status of Features]]

User:RemDogKap/SandBox/Status of Features

2023-06-10T00:37:35Z

RemDogKap: updated notes for SD Card to mention the speed limitation

{|class="wikitable" style="margin:auto"
|+pinix
! style=width:100px | Feature !! style=width:100px | Status !! style=width:300px | Notes !! style=width:200px | More info
|-
| SD Card Boot || style="background-color:#9eff9e" | Working || There is a design flaw such that the SD card can only receive 3.3V and not the 1.8V required for speeds over 20 MB/s. || #Star64
|-
| eMMC Boot || style="background-color:#9eff9e" | Working || || #Star64
|-
| UART Boot || style="background-color:#9eff9e" | Not Tested, assumed working|| The only current known use for UART boot is the [https://github.com/starfive-tech/Tools recovery tool from StarFive] ||
|-
| PCIE/NVME Boot || style="background-color:#ebc934" | Partially Implemented || || #Star64 @Tenkawa
|-
| USB 2.0 || style="background-color:#9eff9e" | Working || A design flaw means that USB overcurrent protection is disabled so be careful ||
|-
| USB 3.0 || style="background-color:#9eff9e" | Working || ||
|-
| 4K Output || style="background-color:#ebc934" | Partially Implemented || || #Star64 @Fishwaldo
|-
| 4K HDR || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| H.264 || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| H.265 || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| 3.5mm audio Jack || style="background-color:#9eff9e" | Working || ||
|-
| Ethernet || style="background-color:#9eff9e" | Working || ||
|-
| Wifi || style="background-color:#9eff9e" | working || ||
|-
| PCIe 2.0 ×1 lane || style="background-color:#9eff9e" | Working || ||
|-
| "Pi2" GPIO || style="background-color:#9eff9e" | Working || ||
|-
| TTL UART || style="background-color:#9eff9e" | Working || ||
|}

File:Star64 SD switch map.png

2023-06-09T23:48:30Z

RemDogKap: Image of the correct dip switch settings to boot from SD Card for the Star64 SBC.

== Summary ==
Image of the correct dip switch settings to boot from SD Card for the Star64 SBC.

== Licensing ==
{{PD|PD}}

File:Star64 EMMC switch map.png

2023-06-09T23:47:34Z

RemDogKap: Image of the correct dip switch settings to boot from eMMC for the Star64 SBC.

== Summary ==
Image of the correct dip switch settings to boot from eMMC for the Star64 SBC.
== Licensing ==
{{PD|PD}}

User:RemDogKap/SandBox/First Setup

2023-06-09T23:18:37Z

RemDogKap: combined eMMC and SD card sections

The Star64 is a 64 bit, 4 core Single Board Computer.

==Prerequisites==

*[https://pine64.com/product-category/star64/ Star64 SBC]
*[https://pine64.com/product-category/star64-accessories/ 12V 3A to 5A Power Supply] (Any 12V 3A or 5A type M 5.5mm OD/2.1mm ID barrel type DC Jack Power Supply will work)
*One or more types of removeable flash memory
**[https://pine64.com/product/64gb-class10-microsd-card/ SD card] of at least ??GB, no greater than 256GB
**[https://pine64.com/product-category/star64-accessories/ eMMC Module] with [https://pine64.com/product/usb-adapter-for-emmc-module/ USB adapter]
*Ability to flash a storage device with a disk image. [https://etcher.balena.io/ Balena Etcher] is recommended, but advanced users can also use dd in a Unix-like OS

==Flashing the image==
There are currently two working distributions of Linux compatible with the Star64, pinix and Armbian. Both distributions use the same kernel[???].The pinix distribution is a custom distribution built by Fishwaldo using Yocto which is an open source project used to create Linux distributions for embedded devices. The pinix distribution is currently focusing on support for GPU and VGPU acceleration for desktop environments. Both distributions use the deb package manager. The Armbian distribution is based on Debian/Ubuntu with changes to make it lightweight and compatible with ARM/RISC-V development boards.

While there are other RISC-V compatible distributions, none of these have the required device tree entries for the Star64 meaning that none will work fully on the Star64. This includes images for the StarFive2, a sister board which uses the same processor, due to other hardware differences. It may be possible to get other distributions to run on the Star64 by cross compiling the working kernel into another distribution.

More information about support for features can be accessed [[Status_of_Features | here]].
===pinix Install===

====Linux====

First, if not already installed, install bzip2 and wget.
$ sudo apt update && sudo apt install bzip2 wget

Second, download a compressed disk image (.wic.bz2) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) using wget. There are three types of images, one command line only and two desktop environments.
*star64-image-minimal - A command line only image
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

$ wget <nowiki>https://pine64.my-ho.st:8443/${Name of Image File}</nowiki>

Where ${Name of Image File} is the name of your chosen image file.
Example:

$ wget <nowiki>https://pine64.my-ho.st:8443/star64-image-minimal-star64-1.2.wic.bz2</nowiki>

Next, decompress the file using bzip2.

$ bzip2 -d ${Path to Image File}

Where ${Path to Image File} is the path to your image file. Example:

$ bzip2 -d star64-image-minimal-star64-1.2.wic.bz2

Next, flash the image to the SD card or eMMC module. The open source Balena Etcher with GUI support is recommended but dd will work as well if you are an advanced user.

====Windows====

First, make sure that you have [https://7-zip.org/ 7zip] installed and if not, install it.

Second, download a compressed disk image (.wic.bz2) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) by clicking on the files. There are three types of images, one command line only and two desktop environments.
*star64-image-minimal - A command line only image
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

Third, right click on the downloaded file and select 7-zip. Next click extract.

Finally, use Balena Etcher to write your disk image to the SD Card or eMMC module .

===Armbian Install===

==Booting the Image==

User:RemDogKap/SandBox

2023-06-09T23:16:43Z

RemDogKap: added 2 todos

Links to documentation pages I am currently working on for the Star64 SBC

ToDo:
*Explain that SD Card does not work at full speed
*Tutorial for loading disk images onto eMMC
*How to update XSPI U-Boot
*How to use NVME drives
*working state of various USB ports
*list hardware bugs
**SD Card Voltage
**USB over current
*Armbian Install
*Memory DTB fix/recompile eeprom thing
*How to flash eMMC from SD card if possible
*Things needed to build you own working image

[[/First Setup]]

[[/Storage Formats]]

[[/Status of Features]]

User:RemDogKap/SandBox/Status of Features

2023-06-09T22:10:55Z

RemDogKap: updated statuses and added color

{|class="wikitable" style="margin:auto"
|+pinix
! style=width:100px | Feature !! style=width:100px | Status !! style=width:300px | Notes !! style=width:200px | More info
|-
| SD Card Boot || style="background-color:#9eff9e" | Working || Some people have found trouble booting from the SD card but success in booting from the XSPI flash || #Star64
|-
| eMMC Boot || style="background-color:#9eff9e" | Working || || #Star64
|-
| UART Boot || style="background-color:#9eff9e" | Not Tested, assumed working|| The only current known use for UART boot is the [https://github.com/starfive-tech/Tools recovery tool from StarFive] ||
|-
| PCIE/NVME Boot || style="background-color:#ebc934" | Partially Implemented || || #Star64 @Tenkawa
|-
| USB 2.0 || style="background-color:#9eff9e" | Working || A design flaw means that USB overcurrent protection is disabled so be careful ||
|-
| USB 3.0 || style="background-color:#9eff9e" | Working || ||
|-
| 4K Output || style="background-color:#ebc934" | Partially Implemented || || #Star64 @Fishwaldo
|-
| 4K HDR || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| H.264 || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| H.265 || style="background-color:#ffc7c7" | Not Implemented || ||
|-
| 3.5mm audio Jack || style="background-color:#9eff9e" | Working || ||
|-
| Ethernet || style="background-color:#9eff9e" | Working || ||
|-
| Wifi || style="background-color:#9eff9e" | working || ||
|-
| PCIe 2.0 ×1 lane || style="background-color:#9eff9e" | Working || ||
|-
| "Pi2" GPIO || style="background-color:#9eff9e" | Working || ||
|-
| TTL UART || style="background-color:#9eff9e" | Working || ||
|}

User:RemDogKap/SandBox/Status of Features

2023-06-08T23:52:19Z

RemDogKap: Initial rough out of hardware feature statuses

{|class="wikitable" style="margin:auto"
|+pinix
! style=width:100px | Feature !! style="width:100px | Status !! style=width:300px | Notes !! style=width:200px | More info
|-
| SD Card Boot || Working || Some people have found trouble booting from the SD card but success in booting from the XSPI flash || #Star64
|-
| eMMC Boot || ???? || || #Star64
|-
| UART Boot || Not Implemented || ||
|-
| PCIE/NVME Boot || Partially Implemented || || #Star64 @Tenkawa
|-
| USB 2.0 || Partially Implemented || There is currently a hardware bug with overcurrent protection which requires a workaround ||
|-
| USB 3.0 || ???? || Same hardware bug as USB 2.0. ||
|-
| 4K Output || Partially Implemented || || #Star64 @Fishwaldo
|-
| 4K HDR || Not Implemented || ||
|-
| H.264 || Not Implemented || ||
|-
| H.265 || Not Implemented || ||
|-
| 3.5mm audio Jack || ???? || ||
|-
| Ethernet || Working || ||
|-
| Wifi || ???? || ||
|-
| PCIe 2.0 ×1 lane || Working || ||
|-
| "Pi2" GPIO || Working || ||
|-
| TTL UART || Working || ||
|}

User:RemDogKap/SandBox/First Setup

2023-06-08T20:16:31Z

RemDogKap: minor edits and how to flash sd card on windows

The Star64 is a 64 bit, 4 core Single Board Computer.

==Prerequisites==

*[https://pine64.com/product-category/star64/ Star64 SBC]
*[https://pine64.com/product-category/star64-accessories/ 12V 3A to 5A Power Supply] (Any 12V 3A or 5A type M 5.5mm OD/2.1mm ID barrel type DC Jack Power Supply will work)
*One or more types of removeable flash memory
**[https://pine64.com/product/64gb-class10-microsd-card/ SD card] of at least ??GB, no greater than 256GB
**[https://pine64.com/product-category/star64-accessories/ eMMC Module] with [https://pine64.com/product/usb-adapter-for-emmc-module/ USB adapter]
*Ability to flash a storage device with a disk image. [https://etcher.balena.io/ Balena Etcher] is recommended, but advanced users can also use dd in a Unix-like OS

==Flashing the image==
There are currently two working distributions of Linux compatible with the Star64, pinix and Armbian. Both distributions use the same kernel[???].The pinix distribution is built using Yocto which is an open source project used to create Linux distributions for embedded devices. The pinix distribution is currently focusing on support for GPU and VGPU acceleration for desktop environments. Both distributions use the deb package manager. The Armbian distribution is based on Debian/Ubuntu with changes to make it lightweight and compatible with ARM/RISC-V development boards.

While there are other RISC-V compatible distributions, none of these have the required device tree entries for the Star64 meaning that none will work fully on the Star64. This includes images for the StarFive2, a sister board which uses the same processor, due to other hardware differences. It may be possible to get other distributions to run on the Star64 by cross compiling the working kernel into another distribution.

More information about support for features can be accessed [[Status_of_Features | here]].
===pinix Install===

====Linux====

First, if not already installed, install bzip2 and wget.
$ sudo apt update && sudo apt install bzip2 wget

Second, download a compressed disk image (.wic.bz2) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) using wget. There are three types of images, one command line only and two desktop environments.
*star64-image-minimal - A command line only image
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

$ wget <nowiki>https://pine64.my-ho.st:8443/${Name of Image File}</nowiki>

Where ${Name of Image File} is the name of your chosen image file.
Example:

$ wget <nowiki>https://pine64.my-ho.st:8443/star64-image-minimal-star64-1.2.wic.bz2</nowiki>

Next, decompress the file using bzip2.

$ bzip2 -d ${Path to Image File}

Where ${Path to Image File} is the path to your image file. Example:

$ bzip2 -d star64-image-minimal-star64-1.2.wic.bz2

Next, flash the image to the SD card. The open source Balena Etcher with GUI support is recommended but dd will work as well if you are an advanced user.

====Windows====

First, make sure that you have [https://7-zip.org/ 7zip] installed and if not, install it.

Second, download a compressed disk image (.wic.bz2) from [https://pine64.my-ho.st:8443/ here] (source code available [https://github.com/Fishwaldo/meta-pine64 here]) by clicking on the files. There are three types of images, one command line only and two desktop environments.
*star64-image-minimal - A command line only image
*star64-image-weston - A Weston/Wayland "Demo" image.
*star64-image-plasma- A Plasma Based Image.

Third, right click on the downloaded file and select 7-zip. Next click extract.

Finally, use Balena Etcher to write your disk image to the SD Card.

===Armbian Install===

===SD Card===

===eMMC Flash===
[Not sure if eMMC flash is any different, I (Rem) do not have experience using it]
====Using SD Card====
[As mbuggle said in Discord #Star64 on 2023-06-05 1:10 AM CDT (Message ID: 1115160713439223859) it seems like it may be possible to use an SD Card to first boot, use the SSD to transfer the disk image to the eMMC, remove the SD Card and boot from eMMC]
====Using eMMC to USB Adapter====

==Booting the Image==

User:RemDogKap/SandBox/First Setup

2023-06-08T16:03:18Z

RemDogKap: minor formatting

User:RemDogKap/SandBox

2023-06-08T16:00:02Z

RemDogKap: added memory issue as ToDo

Links to documentation pages I am currently working on for the Star64 SBC

ToDo:
*Explain that SD Card does not work at full speed
*Tutorial for loading disk images onto eMMC
*How to update XSPI U-Boot
*How to use NVME drives
*working state of various USB ports
*list hardware bugs
**SD Card Voltage
**USB over current
*Armbian Install
*Memory DTB fix/recompile eeprom thing

[[/First Setup]]

[[/Storage Formats]]

[[/Status of Features]]

User:RemDogKap/SandBox

2023-06-08T14:17:25Z

RemDogKap: Added ToDos

Links to documentation pages I am currently working on for the Star64 SBC

ToDo:
*Explain that SD Card does not work at full speed
*Tutorial for loading disk images onto eMMC
*How to update XSPI U-Boot
*How to use NVME drives
*working state of various USB ports
*list hardware bugs
**SD Card Voltage
**USB over current
*Armbian Install

[[/First Setup]]

[[/Storage Formats]]

[[/Status of Features]]

User:RemDogKap/SandBox/First Setup

2023-06-08T04:46:15Z

RemDogKap: began section on flashing the image

User:RemDogKap/SandBox/First Setup

2023-06-08T02:43:09Z

RemDogKap: Prereqs rough out

User:RemDogKap/SandBox

2023-06-08T02:13:24Z

RemDogKap: Initial Outline

Links to documentation pages I am currents working on for the Star64 SBC

[[/First Setup]]

[[/Storage Formats]]

[[/Status of Features]]

User:RemDogKap

2023-06-08T02:12:02Z

RemDogKap: Insert Sandbox Link

[[/SandBox]]