PINE64 - User contributions [en]

Talk:Ox64

2024-01-19T03:57:20Z

Pavlos1: /* Does DevCube 1.8.8 work? */ new section

== Flash memory producer ==

Hello. On this page I see datasheets for Gigadevice flash memory, but on my boards placed Winbond flash. Maybe we need to update datasheets?--[[User:ElektroNIK|ElektroNIK]] ([[User talk:ElektroNIK|talk]]) 11:58, 20 January 2023 (UTC)

== I disagree with the name of section 10 ==

[Placeholder for the initial message by [[User:Pavlos1]]]

: Hello! Did you mean that the "Flashing Ox64 SBC and SD Card for Newbies" section title should be reworded? I'd agree about that, and I'd suggest that the "for Newbies" part is simply dropped. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:00, 4 January 2024 (UTC)

:: Went ahead and implemented [https://wiki.pine64.org/index.php?title=Ox64&type=revision&diff=21262&oldid=21257 this edit]. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:55, 4 January 2024 (UTC)

== Regarding PIP and --break-system-packages ==

To [[User:Giorez]] and other editors:

The instructions in the [https://wiki.pine64.org/wiki/Ox64#Open-Source_Flashing_Using_CLI Open-Source Flashing Using CLI] section involve installing a PIP package. Doing so is a bit awkward due to conflicts with system packages. I used to do it as follows, but for whatever reason that doesn't work anymore (at least on Gentoo and Arch).

<pre>
pip install --user $PACKAGE
</pre>

In the article itself I suggested creating a virtual environment as follows. That seems to be the "preferred" way of managing a separate set of Python packages to the ones installed by the OS package manager.

<pre>
python -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install $PACKAGE
</pre>

Note that when you run <code>pip install</code> with the virtual environment activated, it installs the package ''to'' the virtual environment. So you need to re-activate the virtual environment each time you open a new terminal window; otherwise <code>bflb-iot-tool</code> will not be in your <code>PATH</code>.

The following is not recommended since it is instructing PIP to potentially introduce conflicts with system packages. And to be clear: running the command below is *not* necessary if you have already set up the virtual environment as described above.

<pre>
sudo pip install $PACKAGE --break-system-packages
</pre>

-- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 03:22, 6 January 2024 (UTC)

: I agree with the way you described it above. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:13, 6 January 2024 (UTC)

I agree, sorry for keep editing my original post. I'm not expert in linux system. I just started this article, because i has been really frustrated to find a full tutorial for newbies. And i usually look for newbie tips to share/get help from expert people like you. thank for your contribution. -- [[User:Giorez|Giorez]] ([[User talk:Giorez|talk]]) 10:53, 7 January 2024 (UTC)

: That's all good. Thanks for testing out my flashing instructions — these things don't always work the same way across different Linux systems. -- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 12:12, 7 January 2024 (UTC)

== Does DevCube 1.8.8 work? ==

If so, we don't have to have a direct-download link (or SHA hashes) to any particular version; we can just instruct users to download the latest release. But please confirm that DevCube 1.8.8 does in fact successfully flash OpenBouffalo images before doing so. -- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 03:57, 19 January 2024 (UTC)

Ox64

2024-01-19T03:43:30Z

Pavlos1: /* Build */ menuconfig navigation fix

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==
Open the terminal and create a new directory for the build:

cd ~/Downloads/ox64
mkdir buildroot_bouffalo && cd buildroot_bouffalo

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:

git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo

Define an environment variable for the Buildroot Bouffalo overlay path:

export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo

Change directory into the cloned Buildroot folder:

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot

Apply the default configuration for Pine64 Ox64:

make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
# make clean # deletes all the already compiled object files

Use the <code>menuconfig</code> tool to adjust the build settings:

make menuconfig

[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Within <code>menuconfig</code>, configure the following:
* Navigate to <code>Target Options</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process, but make sure first that your <code>PATH</code> variable contains no spaces:

make

You will get the image files required for flashing in the <code>output/images</code> directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube
cd ~/Downloads/ox64/devcube

Get the DevCube 1.8.8 flasher from one of mirror servers listed below.

* https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip

Verify the file hashes listed below.

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

Finally, uncompress the downloaded archive; for example:

wget https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip
sha256sum BouffaloLabDevCube-v1.8.8.zip
unzip BouffaloLabDevCube-v1.8.8.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need the following files for the flashing process.

* <code>m0_lowload_bl808_m0.bin</code>
* <code>d0_lowload_bl808_d0.bin</code>
* <code>bl808-firmware.bin</code>
* <code>sdcard.img</code>

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===
Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to the [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====
For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv python3.11-venv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool ''# we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====
Note that the addresses are different according to the flashing method, DevCube or CLI.

DevCube CLI
M0 address 0x58000000 0x000000
D0 address 0x58100000 0x100000
LP address 0x58200000 0x200000

=== Flash Your microSD Card ===
Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== Booting for the First Time ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board, using the following parameters.

* UART TX is physical pin 32/GPIO 16
* UART RX is physical pin 31/GPIO 17
* Baud rate is 2000000

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Ox64

2024-01-19T03:36:19Z

Pavlos1: /* Build */ `make new` is not a valid buildroot target

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==
Open the terminal and create a new directory for the build:

cd ~/Downloads/ox64
mkdir buildroot_bouffalo && cd buildroot_bouffalo

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:

git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo

Define an environment variable for the Buildroot Bouffalo overlay path:

export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo

Change directory into the cloned Buildroot folder:

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot

Apply the default configuration for Pine64 Ox64:

make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
# make clean # deletes all the already compiled object files

Use the <code>menuconfig</code> tool to adjust the build settings:

make menuconfig

[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Within <code>menuconfig</code>, configure the following:
* Navigate to <code>Target Options > Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process, but make sure first that your <code>PATH</code> variable contains no spaces:

make

You will get the image files required for flashing in the <code>output/images</code> directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube
cd ~/Downloads/ox64/devcube

Get the DevCube 1.8.8 flasher from one of mirror servers listed below.

* https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip

Verify the file hashes listed below.

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

Finally, uncompress the downloaded archive; for example:

wget https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip
sha256sum BouffaloLabDevCube-v1.8.8.zip
unzip BouffaloLabDevCube-v1.8.8.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need the following files for the flashing process.

* <code>m0_lowload_bl808_m0.bin</code>
* <code>d0_lowload_bl808_d0.bin</code>
* <code>bl808-firmware.bin</code>
* <code>sdcard.img</code>

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===
Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to the [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====
For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv python3.11-venv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool ''# we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====
Note that the addresses are different according to the flashing method, DevCube or CLI.

DevCube CLI
M0 address 0x58000000 0x000000
D0 address 0x58100000 0x100000
LP address 0x58200000 0x200000

=== Flash Your microSD Card ===
Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== Booting for the First Time ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board, using the following parameters.

* UART TX is physical pin 32/GPIO 16
* UART RX is physical pin 31/GPIO 17
* Baud rate is 2000000

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Ox64

2024-01-19T03:06:00Z

Pavlos1: Undo revision 21394 by Giorez (talk); addresses are incorrect

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==
Open the terminal and create a new directory for the build:

cd ~/Downloads/ox64
mkdir buildroot_bouffalo && cd buildroot_bouffalo

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:

git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo

Define an environment variable for the Buildroot Bouffalo overlay path:

export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo

Change directory into the cloned Buildroot folder:

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot

Apply the default configuration for Pine64 Ox64:

make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
# make clean # deletes all the already compiled object files
# make new # and it will recompile everything again

Use the <code>menuconfig</code> tool to adjust the build settings:

make menuconfig

[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Within <code>menuconfig</code>, configure the following:
* Navigate to <code>Target Options > Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process, but make sure first that your <code>PATH</code> variable contains no spaces:

make

You will get the image files required for flashing in the <code>output/images</code> directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube
cd ~/Downloads/ox64/devcube

Get the DevCube 1.8.8 flasher from one of mirror servers listed below.

* https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip

Verify the file hashes listed below.

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

Finally, uncompress the downloaded archive; for example:

wget https://dev.bouffalolab.com/media/upload/download/BouffaloLabDevCube-v1.8.8.zip
sha256sum BouffaloLabDevCube-v1.8.8.zip
unzip BouffaloLabDevCube-v1.8.8.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need the following files for the flashing process.

* <code>m0_lowload_bl808_m0.bin</code>
* <code>d0_lowload_bl808_d0.bin</code>
* <code>bl808-firmware.bin</code>
* <code>sdcard.img</code>

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===
Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to the [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====
For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv python3.11-venv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool ''# we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====
Note that the addresses are different according to the flashing method, DevCube or CLI.

DevCube CLI
M0 address 0x58000000 0x000000
D0 address 0x58100000 0x100000
LP address 0x58200000 0x200000

=== Flash Your microSD Card ===
Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== Booting for the First Time ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board, using the following parameters.

* UART TX is physical pin 32/GPIO 16
* UART RX is physical pin 31/GPIO 17
* Baud rate is 2000000

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Talk:Ox64

2024-01-07T12:12:27Z

Pavlos1:

== Flash memory producer ==

Hello. On this page I see datasheets for Gigadevice flash memory, but on my boards placed Winbond flash. Maybe we need to update datasheets?--[[User:ElektroNIK|ElektroNIK]] ([[User talk:ElektroNIK|talk]]) 11:58, 20 January 2023 (UTC)

== I disagree with the name of section 10 ==

[Placeholder for the initial message by [[User:Pavlos1]]]

: Hello! Did you mean that the "Flashing Ox64 SBC and SD Card for Newbies" section title should be reworded? I'd agree about that, and I'd suggest that the "for Newbies" part is simply dropped. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:00, 4 January 2024 (UTC)

:: Went ahead and implemented [https://wiki.pine64.org/index.php?title=Ox64&type=revision&diff=21262&oldid=21257 this edit]. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:55, 4 January 2024 (UTC)

== Regarding PIP and --break-system-packages ==

To [[User:Giorez]] and other editors:

The instructions in the [https://wiki.pine64.org/wiki/Ox64#Open-Source_Flashing_Using_CLI Open-Source Flashing Using CLI] section involve installing a PIP package. Doing so is a bit awkward due to conflicts with system packages. I used to do it as follows, but for whatever reason that doesn't work anymore (at least on Gentoo and Arch).

<pre>
pip install --user $PACKAGE
</pre>

In the article itself I suggested creating a virtual environment as follows. That seems to be the "preferred" way of managing a separate set of Python packages to the ones installed by the OS package manager.

<pre>
python -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install $PACKAGE
</pre>

Note that when you run <code>pip install</code> with the virtual environment activated, it installs the package ''to'' the virtual environment. So you need to re-activate the virtual environment each time you open a new terminal window; otherwise <code>bflb-iot-tool</code> will not be in your <code>PATH</code>.

The following is not recommended since it is instructing PIP to potentially introduce conflicts with system packages. And to be clear: running the command below is *not* necessary if you have already set up the virtual environment as described above.

<pre>
sudo pip install $PACKAGE --break-system-packages
</pre>

-- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 03:22, 6 January 2024 (UTC)

: I agree with the way you described it above. -- [[User:Dsimic|Dsimic]] ([[User talk:Dsimic|talk]]) 17:13, 6 January 2024 (UTC)

-- [[User:Giorez|Giorez]] ([[User talk:Giorez|talk]]) 10:53, 7 January 2024 (UTC) I agree, sorry for keep editing my original post. I'm not expert in linux system. I just started this article, because i has been really frustrated to find a full tutorial for newbies. And i usually look for newbie tips to share/get help from expert people like you. thank for your contribution.

: That's all good. Thanks for testing out my flashing instructions — these things don't always work the same way across different Linux systems. -- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 12:12, 7 January 2024 (UTC)

User talk:Pavlos1

2024-01-06T11:48:07Z

Pavlos1:

how do i reply to pavlos1 comment.

: You have to edit the talk page in the same way you edit a normal article. Use <code><nowiki>:</nowiki></code> to create an indentation, and <code><nowiki>-- ~~~~</nowiki></code> to sign off. -- [[User:Pavlos1|Pavlos1]] ([[User talk:Pavlos1|talk]]) 11:48, 6 January 2024 (UTC)

Talk:Ox64

2024-01-06T03:22:53Z

Pavlos1: /* Regarding PIP and --break-system-packages */

Talk:Ox64

2024-01-06T03:02:24Z

Pavlos1: /* Regarding PIP and --break-system-packages */ new section

Ox64

2024-01-06T02:13:52Z

Pavlos1: /* Open-Source Flashing Using CLI */

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==
Open the terminal and create a new directory for the build:

mkdir buildroot_bouffalo && cd buildroot_bouffalo

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:

git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo

Define an environment variable for the Buildroot Bouffalo overlay path:

export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo

Change directory into the cloned Buildroot folder:

cd buildroot

Apply the default configuration for Pine64 Ox64:

make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig

Use the <code>menuconfig</code> tool to adjust the build settings:

make menuconfig

[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Within <code>menuconfig</code>, configure the following:
* Navigate to <code>Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process, but make sure first that your <code>PATH</code> variable contains no spaces:

make

You will get the image files required for flashing in the <code>output/images</code> directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get the DevCube 1.8.3 flasher from one of mirror servers listed below.

* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

Verify the file hashes listed below.

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

Finally, uncompress the downloaded archive; for example:

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
sha256sum BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need the following files for the flashing process.

* <code>m0_lowload_bl808_m0.bin</code>
* <code>d0_lowload_bl808_d0.bin</code>
* <code>bl808-firmware.bin</code>
* <code>sdcard.img</code>

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===
Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to the [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====
For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool ''# we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====
Note that addresses are different according the flashing method: DevCube or CLI.

DevCube CLI
M0 address = 0x58000000 or = 0x000000
D0 address = 0x58100000 or = 0x100000
LP address = 0x58200000 or = 0x200000

=== Flash Your microSD Card ===
Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== Booting for the First Time ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board, using the following parameters.

* UART TX is physical pin 32/GPIO 16
* UART RX is physical pin 31/GPIO 17
* Baud rate is 2000000

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Ox64

2024-01-05T01:38:31Z

Pavlos1: /* Flashing Ox64 SBC and microSD Card */

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

You will get the flashing files into the "/output/images/" directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get the DevCube 1.8.3 flasher from one of mirrored servers, verify the hashes listed below, and decompress it.

* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need following files for the flashing process.

m0_lowload_bl808_m0.bin
d0_lowload_bl808_d0.bin
bl808-firmware.bin
sdcard.img

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===

Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====

For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool # ''we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====

Note that addresses are different according the flashing method: DevCube or CLI.

DevCube CLI
For M0 set address = 0x58000000 or = 0x000000
For D0 set address = 0x58100000 or = 0x100000
For LP set address = 0x58200000 or = 0x200000

=== Flash Your MicroSD Card ===

Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board.

* Serial console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Ox64

2024-01-05T01:37:18Z

Pavlos1: --break-system-packages is a bad idea; the whole point of setting up the venv was to avoid it

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

You will get the flashing files into the "/output/images/" directory

== Flashing Ox64 SBC and microSD Card ==
This section explains how to flash an Ox64 board and a microSD card to boot the system. The required skill levels are fit even for newbies.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files.

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get the DevCube 1.8.3 flasher from one of mirrored servers, verify the hashes listed below, and decompress it.

* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll need following files for the flashing process.

m0_lowload_bl808_m0.bin
d0_lowload_bl808_d0.bin
bl808-firmware.bin
sdcard.img

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===

Open a terminal and check the connected USB serial devices.

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode.

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>.

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode.

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher.

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab.

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab.

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing Using CLI ====

For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment as follows.

sudo apt install virtualenv python3-virtualenv
python3 -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool # ''we are *not* using bflb-mcu-tool''

Note that each time you open a new terminal window you will need to re-run <code>. ~/ox64_venv/bin/activate</code> to reactivate the virtual environment.

Next, put Ox64 in programming mode (press the BOOT button when first applying power) and flash the BL808.

PORT=/dev/ttyACM1 ''# this will depend on which serial adapter you use''
BAUD=115200 ''# safe value for macOS, if using Linux set to 2000000 for faster flashing''
cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware bl808-firmware.bin --single

If you get permission errors when running the commands above, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== BL808 Address Details ====

Note that addresses are different according the flashing method: DevCube or CLI.

DevCube CLI
For M0 set address = 0x58000000 or = 0x000000
For D0 set address = 0x58100000 or = 0x100000
For LP set address = 0x58200000 or = 0x200000

=== Flash Your MicroSD Card ===

Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card and proceed to flashing.

cd ~/Downloads/ox64/buildroot_bouffalo/buildroot/output/images
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=sdcard.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===
Insert microSD card into Ox64 and set a UART connection to the Ox64 board.

* Serial console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Talk:Ox64

2024-01-04T15:44:51Z

Pavlos1: /* I disagree with the name of section 10 */

Talk:Ox64

2024-01-04T15:43:52Z

Pavlos1: /* I disagree with the name of section 10 */ new section

Ox64

2024-01-04T15:20:40Z

Pavlos1: Clarified open source flashing instructions

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources and Articles ==
* [https://youtube.com/watch?v=czRtF-UNiEY A short video] on how to connect to the Ox64, flash and boot
* [https://youtu.be/vPAk5sq_Ilc Another video] that covers soldering pins, connecting via Pi Pico and flashing Linux and U-Boot
* [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf Step-by-step tutorial] for how to build, flash and run Ox64
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First batch of Ox64 won't appear as USB serial port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64 Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Ox64 BL808 RISC-V SBC articles by [https://lupyuen.codeberg.page/ Lup Yuen LEE]:
* [https://lupyuen.codeberg.page/articles/ox64.html Booting Linux and (maybe) Apache NuttX RTOS]
* [https://lupyuen.codeberg.page/articles/ox2.html Starting Apache NuttX real-time operating system]
* [https://lupyuen.codeberg.page/articles/mmu.html Sv39 Memory Management Unit]
* [https://lupyuen.codeberg.page/articles/app.html NuttX Apps and Initial RAM Disk]
* [https://lupyuen.codeberg.page/articles/plic2.html UART Interrupt and Platform-Level Interrupt Controller (PLIC)]
* [https://lupyuen.codeberg.page/articles/plic3.html Fixing the UART Interrupt and Platform-Level Interrupt Controller]
* [https://www.hackster.io/lupyuen/8-risc-v-sbc-on-a-real-time-operating-system-ox64-nuttx-474358 $8 RISC-V SBC on a Real-Time Operating System: Ox64 + NuttX]
* [https://lupyuen.codeberg.page/articles/nim.html Nim on a Real-Time Operating System: Apache NuttX RTOS + Ox64 BL808 SBC]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (initial development has been postponed until further notice)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

== Flashing Ox64 SBC and SD Card for Newbies==
This section explains how to flash Ox64 board and the SD card to boot the system. The required skills are very basic and fit for newbies.

=== Prepare the Environment ===
You need a Linux machine, a Raspberry Pi Pico to act as a UART adapter, the Ox64 board, and a microSD card.

Start a terminal session and set the working directory to download some files

cd ~/Downloads
mkdir ox64 ox64/pico
cd ~/Downloads/ox64/pico
wget https://github.com/Kris-Sekula/Pine64_Ox64_SBC/blob/main/uart/picoprobe.uf2

cd ~/Downloads/ox64
mkdir ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get the DevCube 1.8.3 flasher from one of mirrored servers, verify the hashes listed below, and decompress it:

* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

* SHA1: <code>0f2619e87d946f936f63ae97b0efd674357b1166</code>
* SHA256: <code>e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913</code>

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll get the following file and directory structure:

|_ firmware/
|_ firmware/m0_lowload_bl808_m0.bin
|_ firmware/bl808-firmware.bin
|_ firmware/d0_lowload_bl808_d0.bin
|_ firmware/sdcard-pine64_ox64_full_defconfig.img.xz

=== Establish Serial Communication from PC to Ox64 using Pi Pico ===
Open a terminal and check the connected USB serial devices:

ls /dev/ttyACM*

Set the Raspberry Pi Pico board into programming mode:

* Press the BootSel button
* Apply power by plugging the USB cable to PC
* Release the BootSel button

''Note: you could also ground pin28 to TP6 while powering.''

Copy <code>picoprobe.uf2</code> file into the new device <code>/media/<user>/RPI-RP2</code>:

cp ~/Downloads/ox64/pico/picoprobe.uf2 /media/<user>/RPI-RP2

After flashing, the device will auto-set in serial UART communication mode according to the following wiring diagram.

[[File:Pine Serial v2.png|thumb|right|Wiring Raspberry Pi Pico to Pine64 Ox64 SBC]]

OX64 PI PICO
uart0_Tx_GPIO14_pin1 <-> uart0_Rx_pin17
uart0_Rx_GPIO15_pin2 <-> uart0_Tx_pin16
Rxd_GPIO17_pin31 <-> uart1_Tx_pin6
Txd_GPIO16_pin32 <-> uart1_Rx_pin7
gnd_pin38 <-> gnd_pin38/3
vbus5v_pin40 <-> vbus5v_pin40

=== Flash Your Ox64 ===
There are two new ports to choose from, <code>/dev/ttyACM0</code> for serial console and <code>/dev/ttyACM1</code> for DevCube flashing.

minicom -b 2000000 -D /dev/ttyACM0

Set the Ox64 board into programming mode:

* Press the BOOT button
* Apply power or re-plug the USB cable
* Release the BOOT button

Close <code>minicom</code>. Open a new terminal window to run the DevCube flasher:

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: UART
Port/SN: /dev/ttyACM1 (make sure you don't use /dev/ttyACM0, it's used by the minicom console)
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab:

Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Port/SN: /dev/ttyACM1 (make sure you don't use ACM0, it's used by minicom console)
Click 'Create & Download' again and wait until it's done
Close DevCube

==== Open-Source Flashing via CLI ====
For those who do not want to use the DevCube, BouffaloLab provides open-source flashing packages <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

''Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.''

First, install <code>bflb-iot-tool</code> using your preferred method of managing PIP packages. One option is to set up a Python virtual environment:

python -m venv ~/ox64_venv
. ~/ox64_venv/bin/activate
pip install bflb-iot-tool # we are *not* using bflb-mcu-tool

Note that each time you open a new terminal window you will need to re-run the second command above to reactivate the virtual environment.

Next, execute the following commands to flash the BL808. Note that the addresses are different to the ones you would use in the DevCube.

''Reminder: UART TX is physical pin 1/GPIO 14, UART RX is physical pin 2/GPIO 15.''

PORT=/dev/ttyACM0 # this will depend on which serial adapter you use
BAUD=115200 # safe value for macOS, if using Linux set to 2000000 for faster flashing

bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x000000 --firmware ~/Downloads/ox64/firmware/m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x100000 --firmware ~/Downloads/ox64/firmware/d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port $PORT --baudrate $BAUD --addr 0x800000 --firmware ~/Downloads/ox64/firmware/bl808-firmware.bin --single

If you get permission errors on Linux, you may need to add your user to the <code>dialout</code> group. Running the commands as <code>root</code> is not recommended since this will make <code>bflb-iot-tool</code> create <code>root</code>-owned files in your home directory.

==== Details on board addresses ====
You can use <code>make flash</code> to flash the firmware from the command line instead of using BLDevCube. The default configuration is to flash to the M0 core, but you can specify the destination core for flashing by modifying the <code>flash_prog_cfg.ini</code> file in the project root.

For M0 set address = 0x000000
For D0 set address = 0x100000
For LP set address = 0x200000

If you are flashing from BLDevCube, set the CPU to <code>Group0</code> and use the following addresses for the different cores:

For M0 set address = 0x58000000
For D0 set address = 0x58100000
For LP set address = 0x58200000

=== Flash Your SD Card ===
Insert microSD card into PC, locate its device file (<code>/dev/sdb</code>, for example), erase the start of the card, and flash the SD card <code>xxx.img</code> file:

cd ~/Downloads/ox64/firmware
xz -v -d -k sdcard-pine64_ox64_full_defconfig.img.xz
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=~/Downloads/ox64/firmware/sdcard-pine64_ox64_full_defconfig.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===
Insert SD card into Ox64 and set a UART connection to the Ox64 board:

* Serial console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

Choose from serial devices <code>/dev/ttyACM0</code> and <code>/dev/ttyACM1</code>, using the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Re-apply power to the Ox64 and enjoy the booting!

[[Category:Ox64]]
[[Category:Bouffalo BL808]]

Ox64

2023-10-30T13:45:15Z

Pavlos1: Updated buildroot config (see: https://github.com/openbouffalo/buildroot_bouffalo/pull/71)

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 Type-C port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources ==
* A video on how to connect to, flash and boot the Ox64 as at 2023-02 (15min) can be found [https://youtube.com/watch?v=czRtF-UNiEY here].
* Another video that covers soldering pins, connecting via Pi Pico and flashing Linux (inc u-boot, as of 2023-Mar-3) posted [https://youtu.be/vPAk5sq_Ilc here].
* A step-by-step tutorial for how to build, flash and run Ox64 [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf here]
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First Batch of Ox64 won't appear as USB Serial Port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First Batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64’s Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (Initial development has been postponed until further notice.)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>
* Enable <code>Integer Multiplication and Division (M)</code>
* Enable <code>Atomic Instructions (A)</code>
* Enable <code>Single-precision Floating-point (F)</code>
* Enable <code>Double-precision Floating-point (D)</code>
* Set <code>Target ABI</code> to <code>lp64d</code>
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

== Flashing Ox64 SBC and SD Card for Newbies==
This section explains how to flash Ox64 board and the SD card to boot the system. It's very low level for newbies.

[[File:Pine Serial v2.png|thumb|right|200px|Wiring Raspberry Pico Pi to Pine64 Ox64 SBC]]

=== Prepare the Environment ===
You need a Linux machine, a Uart module (i.e Raspberry Pico Pi), the Ox64 board and a SD card.

Start a terminal session and set the working directory
cd ~/Downloads
mkdir ox64 ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get flasher DevCube 1.8.3 from one of mirrored servers and decompress it:
* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

''SHA1: 0f2619e87d946f936f63ae97b0efd674357b1166''

''SHA256SUMS: e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913''

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll get this structure
|_ firmware/
|_ firmware/m0_lowload_bl808_m0.bin
|_ firmware/bl808-firmware.bin
|_ firmware/d0_lowload_bl808_d0.bin
|_ firmware/sdcard-pine64_ox64_full_defconfig.img.xz

=== Flash Ox64 ===
Connect the the Uart module (i.e Raspberry Pico Pi) for serial communicate from PC to Ox64

ls /dev/ttyACM*

There are two new ports to choose from : /dev/ttyACM0 /dev/ttyACM1, use the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Set ox64 board to programming mode

* Press BOOT button
* Apply power
* Release BOOT button

Close minicom. Open a new terminal window to run DevCube flasher

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: Uart
Port/SN: /dev/ttyACM1
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab
Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Click 'Create & Download' again and wait until it's done
Close DevCube

=== Alternative: Open-Source Flashing ===
For those who do not want to use the DevCube, BouffaloLab provide open-source flashing packages — <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

: Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.

Execute the following commands to flash the BL808. Note that the addresses are different to the ones you would use in the DevCube.

: Reminder: UART TX is physical pin 1/GPIO 14, UART RX is physical pin 2/GPIO 15.
pip install bflb-iot-tool # we are *not* using bflb-mcu-tool

bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x000000 --firmware firmware/m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x100000 --firmware firmware/d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x800000 --firmware firmware/bl808-firmware.bin --single

=== Flash SD Card ===
Insert SD card into PC, find address [/dev/sdb], erase initial space and flash sdcard.xxxx.img file.

cd ~/Downloads/ox64/openbouffalo/firmware
xz -v -d -k sdcard-pine64_ox64_full_defconfig.img.xz
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=~/Downloads/ox64/openbouffalo/firmware/sdcard-pine64_ox64_full_defconfig.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===

Insert SD card into Ox64 and set a tty connection to Ox64 board
* Serial Console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

minicom -b 2000000 -D /dev/ttyACM0

Re-Apply power to ox64

Enjoy the boot!

PS. To investigate running services
pstree | head -5
init-+-dhcpcd---3*[dhcpcd]
|-dropbear
|-klogd
|-login---sh-+-head
| `-pstree

[[Category:Ox64]] [[Category:Bouffalo BL808]]

Ox64

2023-10-30T11:59:56Z

Pavlos1: Added Winbond flash datasheet

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based single-board computer based on the Bouffalo Lab BL808 RISC-V SoC with C906 64-bit and E907/E902 32-bit CPU cores supported by 64 MB of embedded PSRAM memory, and with built-in WiFi, Bluetooh and Zigbee radio interfaces. The Ox64 comes in a breadboard-friendly form-factor, has a microSD card slot, a USB 2.0 port, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (machine translated to English)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480 MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320 MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150 MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4 GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100 Mbit/s Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16 Mbit (2 MB) or 128 Mbit (16 MB) XSPI NOR flash memory
* MicroSD, supports SDHC and SDXC (only on the 128 Mbit version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO pins, including SPI, I2C and UART functionality, possible I2S and GMII expansion
* Dual-lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on the camera module)
* Speaker (optional, on the camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard dimensions: 51 mm x 21 mm x 19 mm x 3.5 mm (breadboard friendly)
* Input power: 5 V, 0.5 A through the microUSB or USB-C ports

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]
* [https://wiki.pine64.org/images/5/5d/W25Q128JW_RevB_11042019-1761358.pdf Winbond 128Mb QSPI-Flash Datasheet] (W25Q128JWSQ)

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources ==
* A video on how to connect to, flash and boot the Ox64 as at 2023-02 (15min) can be found [https://youtube.com/watch?v=czRtF-UNiEY here].
* Another video that covers soldering pins, connecting via Pi Pico and flashing Linux (inc u-boot, as of 2023-Mar-3) posted [https://youtu.be/vPAk5sq_Ilc here].
* A step-by-step tutorial for how to build, flash and run Ox64 [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf here]
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First Batch of Ox64 won't appear as USB Serial Port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First Batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64’s Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (Initial development has been postponed until further notice.)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>.
* Enable <code>Single-precision Floating-point</code> and <code>Double-precision Floating-point</code>.
* Set <code>Target ABI</code> to <code>lp64d</code>.
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>.
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

== Flashing Ox64 SBC and SD Card for Newbies==
This section explains how to flash Ox64 board and the SD card to boot the system. It's very low level for newbies.

[[File:Pine Serial v2.png|thumb|right|200px|Wiring Raspberry Pico Pi to Pine64 Ox64 SBC]]

=== Prepare the Environment ===
You need a Linux machine, a Uart module (i.e Raspberry Pico Pi), the Ox64 board and a SD card.

Start a terminal session and set the working directory
cd ~/Downloads
mkdir ox64 ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get flasher DevCube 1.8.3 from one of mirrored servers and decompress it:
* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

''SHA1: 0f2619e87d946f936f63ae97b0efd674357b1166''

''SHA256SUMS: e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913''

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll get this structure
|_ firmware/
|_ firmware/m0_lowload_bl808_m0.bin
|_ firmware/bl808-firmware.bin
|_ firmware/d0_lowload_bl808_d0.bin
|_ firmware/sdcard-pine64_ox64_full_defconfig.img.xz

=== Flash Ox64 ===
Connect the the Uart module (i.e Raspberry Pico Pi) for serial communicate from PC to Ox64

ls /dev/ttyACM*

There are two new ports to choose from : /dev/ttyACM0 /dev/ttyACM1, use the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Set ox64 board to programming mode

* Press BOOT button
* Apply power
* Release BOOT button

Close minicom. Open a new terminal window to run DevCube flasher

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: Uart
Port/SN: /dev/ttyACM1
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab
Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Click 'Create & Download' again and wait until it's done
Close DevCube

=== Alternative: Open-Source Flashing ===
For those who do not want to use the DevCube, BouffaloLab provide open-source flashing packages — <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

: Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.

Execute the following commands to flash the BL808. Note that the addresses are different to the ones you would use in the DevCube.

: Reminder: UART TX is physical pin 1/GPIO 14, UART RX is physical pin 2/GPIO 15.
pip install bflb-iot-tool # we are *not* using bflb-mcu-tool

bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x000000 --firmware firmware/m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x100000 --firmware firmware/d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x800000 --firmware firmware/bl808-firmware.bin --single

=== Flash SD Card ===
Insert SD card into PC, find address [/dev/sdb], erase initial space and flash sdcard.xxxx.img file.

cd ~/Downloads/ox64/openbouffalo/firmware
xz -v -d -k sdcard-pine64_ox64_full_defconfig.img.xz
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=~/Downloads/ox64/openbouffalo/firmware/sdcard-pine64_ox64_full_defconfig.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===

Insert SD card into Ox64 and set a tty connection to Ox64 board
* Serial Console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

minicom -b 2000000 -D /dev/ttyACM0

Re-Apply power to ox64

Enjoy the boot!

PS. To investigate running services
pstree | head -5
init-+-dhcpcd---3*[dhcpcd]
|-dropbear
|-klogd
|-login---sh-+-head
| `-pstree

[[Category:Ox64]] [[Category:Bouffalo BL808]]

File:W25Q128JW RevB 11042019-1761358.pdf

2023-10-30T11:51:37Z

Pavlos1: Datasheet: W25Q128JWSQ found on (some) Ox64 boards

== Summary ==
Datasheet: W25Q128JWSQ found on (some) Ox64 boards
== Licensing ==
{{subst:Unknown_copyright}}

Ox64

2023-10-08T13:39:06Z

Pavlos1: Added instructions for open-source flashing

[[File:Ox64_board.jpg|thumb|right|The Ox64]]
[[File:Ox64 pinout.png|thumb|Pinout of the production version]]
[[File:RISC-V.png|thumb|right|Powered by RISC-V]]

The '''Ox64''' is a RISC-V based Single Board Computer powered by Bouffalo Lab BL808 C906 64-Bit RISC-V CPU, 32-Bit CPU, embedded 64MB PSRAM memory and build-on 3 radio RF (Wifi, BT, Zigbee). It provides breadboard friendly form factor, MicroSD Card slot, USB 2.0, and many other peripheral interfaces for makers to integrate with sensors and other devices.

== Software Releases ==

=== Quick Links to the Source of OS Images Build ===

There is a community effort to bring updated kernels, peripherals and buildroot - Lots of communication happening in the #ox64-nutcracker channel.

* [https://github.com/openbouffalo/buildroot_bouffalo buildroot] bringing all the work below together with a bootable kernel and updated filesystem images for SD cards
* [https://github.com/smaeul/u-boot/tree/bl808 U-Boot] and [https://github.com/smaeul/opensbi/tree/bl808 OpenSBI] work by Smauel
* [https://github.com/arm000/linux-bl808/tree/linux-next/mboxic Kernel] IRQChip, SDCard, and (WIP) USB by arm000, Alexander Horner and others
* [https://github.com/openbouffalo/OBLFR OpenBouffalo Firmware] low_load drivers by Fishwaldo and others

Original Linux Images provided by Bouffalo - Very basic '''alpha build''' which are only fit for board bring up and testing purposes.

* [https://github.com/bouffalolab/bl808_linux Linux for BL808]
* [https://wiki.pine64.org/wiki/File:Linux_BL808.pdf Installation Instructions for Linux on BL808 (Chinese)]
* [https://wiki.pine64.org/wiki/File:Linux_BL808_en.pdf Installation Instructions for Linux on BL808 (English Auto-Translation)]

Toolchain:

* elf_newlib_toolchain/bin/riscv64-unknown-elf-gcc (Xuantie-900 elf newlib gcc Toolchain V2.2.5 B-20220323) 10.2.0
* linux_toolchain/bin/riscv64-unknown-linux-gnu-gcc (Xuantie-900 linux-5.10.4 glibc gcc Toolchain V2.2.4 B-20211227) 10.2.0
* cmake version 3.19.3

=== Software Development Kits ===
* [https://github.com/bouffalolab/bl_mcu_sdk BL808 MCU SDK]
* [https://dev.bouffalolab.com/download BLDevCube Flashing Tool for Windows, macOS and Ubuntu x64]
* [https://wiki.pine64.org/wiki/File:Ox64_BL808UART_connect.pdf Ox64 UART Flashing Guide], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/bl808_demo_event.bin BL808 Demo Firmware: bl808_demo_event.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/whole_flash_data.bin BL808 UART Log Firmware: whole_flash_data.bin], see the [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff notes]
* [https://github.com/lupyuen/lupyuen.github.io/releases/download/ox64/BL808.DVK.Quick.Start.pdf BL808 DVK Quick Start]
* [https://github.com/bouffalolab/bl808_linux/tree/main/opensbi-0.6-808 OpenSBI for BL808]
* [https://github.com/bouffalolab/bl-pac/tree/main/bl808 Rust Peripheral Access Crate (PAC) for BL808]
* [https://github.com/bouffalolab/bl-pac/blob/main/bl808/bl808.svd System View Description (SVD) for BL808]

== SoC and Memory Specification ==

[[File:Bouffalo_Lab_icon.png|right]]

Based on the [https://en.bouffalolab.com/product/ Bouffalo Lab BL808]

[[File:BL808_Block_Diagram.jpg|500px]]

=== CPU Architecture ===

[[File:T-Head.png|right|200px]]

T-Head C906 480MHz 64-bit RISC-V CPU:

* Supports RISC-V RV64IMAFCV instruction architecture
* Five-stage single-issue sequentially executed pipeline
* Level-1 instruction and data cache of Harvard architecture, with a size of 32 KB and a cache line of 64B
* Sv39 memory management unit, realizing the conversion of virtual and real addresses and memory management
* jTLB that supports 128 entries
* Supports AXI 4.0 128-bit master interface
* Supports core local interrupt (CLINT) and platform-level interrupt controller (PLIC)
* With 80 external interrupt sources, 3 bits for configuring interrupt priority
* Supports BHT (8K) and BTB
* Compatible with RISC-V PMP, 8 configurable areas
* Supports hardware performance monitor (HPM) units
* See [https://www.t-head.cn/product/c906?lang=en here]

T-Head E907 320MHz 32-bit RISC-V CPU:

* Supports RISC-V RV32IMAFCP instruction set
* Supports RISC-V 32-bit/16-bit mixed instruction set
* Supports RISC-V machine mode and user mode
* Thirty-two 32-bit integer general purpose registers (GPR) and thirty-two 32-bit/64-bit floating-point GPRs
* Integer (5-stage)/floating-point (7-stage), single-issue, sequentially executed pipeline
* Supports AXI 4.0 main device interface and AHB 5.0 peripheral interface
* 32K instruction cache, two-way set associative structure
* 16K data cache, two-way set associative structure
* See [https://www.t-head.cn/product/e907?lang=en here]

T-Head E902 150MHz 32-bit RISC-V CPU:

* See [https://www.t-head.cn/product/e902?lang=en here]

=== System Memory ===
* Embedded 64MB PSRAM

== Board Features ==

=== Network ===
* 2.4GHz 1T1R WiFi 802.11 b/g/n
* Bluetooth 5.2
* Zigbee
* 10/100Mbps Ethernet (optional, on expansion board)

=== Storage ===
* On-board 16Mb (2MB) or 128Mb (16MB) XSPI NOR flash memory
* MicroSD - supports SDHC and SDXC (only 128Mb version)

=== Expansion Ports ===
* USB 2.0 OTG port
* 26 GPIO Pins, including SPI, I2C and UART functionality. Possible I2S and GMII expansion
* Dual lane MiPi CSI port, located at USB-C port, for camera module

=== Audio ===
* Microphone (optional, on camera module)
* Speaker (optional, on camera module)

== Board Information, Schematics and Certifications ==
[[File:Ox64 ethphy.png|thumb|Pinout for wiring ethernet PHY to EMAC]]

* Baseboard Dimensions: 51mm x 21mm x 19mm x 3.5mm (Breadboard friendly)
* Input Power: 5V 0.5A microUSB or USB-C port

Production version schematic:

* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221018.pdf Ox64 Schematic 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221018.pdf Ox64 PCB Component placement(ToP) 20221018 v1.1]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221018.pdf Ox64 PCB Component placement(Bottom) 20221018 v1.1]

Prototype (dispatched to developers) schematic:
* [https://files.pine64.org/doc/ox64/PINE64_Ox64-Schematic-202221007.pdf Ox64 Schematic 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Top-20221007.pdf Ox64 PCB Component placement(ToP) 20221007 v1.0]
* [https://files.pine64.org/doc/ox64/PINE64_Ox64_PCB_Placement-Bottom-20221007.pdf Ox64 PCB Component placement(Bottom) 20221007 v1.0]

Certifications:
* Disclaimer: Please note that PINE64 SBC is not a "final" product and in general certification is not necessary.
* Not yet available

== Datasheets for Components and Peripherals ==

Bouffalo BL808 SoC information:
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_DS/en/BL808_DS_1.2_en.pdf Bouffalo Lab BL808 SoC Datasheet]
* [https://raw.githubusercontent.com/bouffalolab/bl_docs/main/BL808_RM/en/BL808_RM_en_1.3.pdf Bouffalo Lab BL808 SoC Reference Manual]

SPI NOR Flash information:
* [https://files.pine64.org/doc/datasheet/ox64/gd25lq16e_rev1.2_20210108.pdf GigaDevice 16Mb XSPI-Flash Datasheet]
* [https://files.pine64.org/doc/datasheet/star64/gd25lq128e_rev1.0_20210513.pdf GigaDevice 128Mb XSPI-Flash Datasheet]

Power Regulator information:
* [https://files.pine64.org/doc/datasheet/ox64/IA2014-03.pdf Innovation Analog Tech IA2014 Step_down Converter Datasheet]

MicroSD socket information:
* [https://files.pine64.org/doc/datasheet/ox64/TF%20PUSH%20type%20socket%20specification.pdf Push type microSD socket specification]

== Compatible UARTs when in bootloader mode ==

When the Ox64 is in bootloader mode, some UARTs are unable to communicate with it. When this is the case, utilities such as BLDevCube are unable to actually program the device. If you see "Shake hand fail" and an empty ack, and your device is in bootloader mode, then it is likely an incompatible UART.

The below devices have been tested and verified as working:
* Raspberry Pi Pico - running the following [https://github.com/sanjay900/ox64-uart/releases/tag/v1.1 UART firmware] (GP4 and GP5 are used for port 0, GP12 and GP13 for port 1)
* Compiled binary for Pi Pico and connectivity diagram is [https://github.com/Kris-Sekula/Pine64_Ox64_SBC/tree/main/uart here]
* ESP32 with CP210x - bridge the EN pin to ground to disable the ESP32 itself, and then connect the TX on the esp32 to 14 on the Ox64 and RX to pin 15. Note that only baud rate 115200 works, and this doesn't seem to work for everyone)
* Stand-alone CP2102 dongle works at 115200 baud. Brand used was HiLetgo.
* STM32F401 BlackPill - running the [https://github.com/blackmagic-debug/blackmagic/tree/main/src/platforms/blackpillv2 Black Magic Debug] firmware
* STM32F103C8T6 BluePill - running Black Magic Debug.
* Some UART adapters based on the FT232H (note that the FT232RL does not work, and neither does the Pine 64 JTAG)
* Some CH340G based adapters work and some don't.

== Resources ==
* A video on how to connect to, flash and boot the Ox64 as at 2023-02 (15min) can be found [https://youtube.com/watch?v=czRtF-UNiEY here].
* Another video that covers soldering pins, connecting via Pi Pico and flashing Linux (inc u-boot, as of 2023-Mar-3) posted [https://youtu.be/vPAk5sq_Ilc here].
* A step-by-step tutorial for how to build, flash and run Ox64 [https://wiki.pine64.org/images/5/59/How_to_Run_Ox64.pdf here]
* [https://gist.github.com/lupyuen/7a0c697b89abccda8e38b33dfe5ebaff First Batch of Ox64 won't appear as USB Serial Port]
* [https://gist.github.com/lupyuen/2087e9b3fb40aab5e0795bb02a265a3b First Batch of Ox64 tested OK with CH340C/G]
* [https://www.robertlipe.com/bl808-not-symmetric/ First thoughts on the (a)symmetry of Bouffalo Labs BL808 as in Pine64’s Ox64]
* [https://thelittleengineerthatcould.blogspot.com/2022/12/the-8-linux-computer-part-2.html The $8 linux computer (with picoprobe-rp2040 programming instructions)]
* [https://github.com/p4ddy1/pine_ox64/blob/main/build_toolchain_macos.md Building the Xuantie GNU Toolchain for Ox64 on macOS and Apple Silicon]

Git repositories:
* [https://github.com/sfranzyshen/arduino-bl808 Community made Arduino Core specifically for the Bouffalo Labs BL808 RISC-V MCU] (Initial development has been postponed until further notice.)

== Development Efforts ==
* [https://twitter.com/gamelaster/status/1583916501400068096 Ox64 boots Linux successfully]
* [https://twitter.com/btashton/status/1586381334439923713?t=w5xRRUR74HGK2O1Zg_aFyw&s=19 Brennan Ashton is porting Apache NuttX RTOS and OpenAMP (Asymmetric Multiprocessing) to BL808]
* [https://twitter.com/thanos_engine/status/1585153938092761093 Phone Concept for BL808]

== Build==

Open the terminal and create a new directory for the build:
<pre>
mkdir buildroot_bouffalo && cd buildroot_bouffalo
</pre>

Clone the primary Buildroot repository and the specific Buildroot Bouffalo repository:
<pre>
git clone https://github.com/buildroot/buildroot
git clone https://github.com/openbouffalo/buildroot_bouffalo
</pre>

Define an environment variable for the Buildroot Bouffalo overlay path:
<pre>
export BR_BOUFFALO_OVERLAY_PATH=$(pwd)/buildroot_bouffalo
</pre>

Change directory into the cloned Buildroot folder:
<pre>
cd buildroot
</pre>

Apply the default configuration for Pine64 Ox64:
<pre>
make BR2_EXTERNAL=$BR_BOUFFALO_OVERLAY_PATH pine64_ox64_defconfig
</pre>

Use the <code>menuconfig</code> tool to adjust build settings:
<pre>
make menuconfig
</pre>
'''Note''': Within <code>menuconfig</code>:
* Navigate to <code>Target Architecture</code>.
* Enable <code>Single-precision Floating-point</code> and <code>Double-precision Floating-point</code>.
* Set <code>Target ABI</code> to <code>lp64d</code>.
[[File:target ABI setting.png|thumb|right|200px|target ABI setting]]
* Under <code>Toolchain</code>, enable <code>Fortran support</code> and <code>OpenMP support</code>.
[[File:toolchain setting.png|thumb|right|200px|toolchain setting]]

Initiate the build process:
<pre>
make
</pre>
'''Note''': Before executing the <code>make</code> command, ensure your <code>PATH</code> variable doesn't have spaces.

== Flashing Ox64 SBC and SD Card for Newbies==
This section explains how to flash Ox64 board and the SD card to boot the system. It's very low level for newbies.

[[File:Pine Serial v2.png|thumb|right|200px|Wiring Raspberry Pico Pi to Pine64 Ox64 SBC]]

=== Prepare the Environment ===
You need a Linux machine, a Uart module (i.e Raspberry Pico Pi), the Ox64 board and a SD card.

Start a terminal session and set the working directory
cd ~/Downloads
mkdir ox64 ox64/devcube183
cd ~/Downloads/ox64/devcube183

Get flasher DevCube 1.8.3 from one of mirrored servers and decompress it:
* https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
* https://hachyderm.io/@mkroman/110787218805897192 > https://pub.rwx.im/~mk/bouffalolab/BouffaloLabDevCube-v1.8.3.zip
* https://we.tl/t-eJWShQJ4iF
* https://cdn.discordapp.com/attachments/771032441971802142/1145565853962735639/BouffaloLabDevCube-v1.8.3.zip

''SHA1: 0f2619e87d946f936f63ae97b0efd674357b1166''

''SHA256SUMS: e6e6db316359da40d29971a1889d41c9e97d5b1ff1a8636e9e6960b6ff960913''

wget https://openbouffalo.org/static-assets/bldevcube/BouffaloLabDevCube-v1.8.3.zip
unzip BouffaloLabDevCube-v1.8.3.zip
chmod u+x BLDevCube-ubuntu

Download compressed file from https://github.com/openbouffalo/buildroot_bouffalo/releases/ and decompress it.

(You can also get the compressed the file from https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz)

cd ~/Downloads/ox64
mkdir openbouffalo && cd openbouffalo
wget https://github.com/openbouffalo/buildroot_bouffalo/releases/download/v1.0.1/bl808-linux-pine64_ox64_full_defconfig.tar.gz
tar -xvzf bl808-linux-pine64_ox64_full_defconfig.tar.gz

You'll get this structure
|_ firmware/
|_ firmware/m0_lowload_bl808_m0.bin
|_ firmware/bl808-firmware.bin
|_ firmware/d0_lowload_bl808_d0.bin
|_ firmware/sdcard-pine64_ox64_full_defconfig.img.xz

=== Flash Ox64 ===
Connect the the Uart module (i.e Raspberry Pico Pi) for serial communicate from PC to Ox64

ls /dev/ttyACM*

There are two new ports to choose from : /dev/ttyACM0 /dev/ttyACM1, use the lower number.

minicom -b 2000000 -D /dev/ttyACM0

Set ox64 board to programming mode

* Press BOOT button
* Apply power
* Release BOOT button

Close minicom. Open a new terminal window to run DevCube flasher

cd ~/Downloads/ox64/devcube183
./BLDevCube-ubuntu

Select chip [BL808], press Finish and switch to [MCU] tab

M0 Group[group0] Image Addr [0x58000000] [PATH to m0_lowload_bl808_m0.bin]
D0 Group[group0] Image Addr [0x58100000] [PATH to d0_lowload_bl808_d0.bin]
Interface: Uart
Port/SN: /dev/ttyACM1
Uart rate 2000000
UART TX is physical pin 1/GPIO 14.
UART RX is physical pin 2/GPIO 15.
Click 'Create & Download' and wait until it's done

Switch to [IOT] tab
Enable 'Single Download', set Address with 0x800000, choose [PATH to bl808-firmware.bin]
Click 'Create & Download' again and wait until it's done
Close DevCube

=== Alternative: Open-Source Flashing ===
For those who do not want to use the DevCube, BouffaloLab provide open-source flashing packages — <code>bflb-iot-tool</code> and <code>bflb-mcu-tool</code>.

: Note: While these packages do contain binaries in addition to the Python source code, those binaries do not appear to be used for UART flashing.

Execute the following commands to flash the BL808. Note that the addresses are different to the ones you would use in the DevCube.

: Reminder: UART TX is physical pin 1/GPIO 14, UART RX is physical pin 2/GPIO 15.
pip install bflb-iot-tool # we are *not* using bflb-mcu-tool

bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x000000 --firmware firmware/m0_lowload_bl808_m0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x100000 --firmware firmware/d0_lowload_bl808_d0.bin --single
bflb-iot-tool --chipname bl808 --interface uart --port /dev/ttyACM0 --addr 0x800000 --firmware firmware/bl808-firmware.bin --single

=== Flash SD Card ===
Insert SD card into PC, find address [/dev/sdb], erase initial space and flash sdcard.xxxx.img file.

cd ~/Downloads/ox64/openbouffalo/firmware
xz -v -d -k sdcard-pine64_ox64_full_defconfig.img.xz
sudo dd if=/dev/zero of=/dev/sdb count=1 bs=32768
sudo dd if=~/Downloads/ox64/openbouffalo/firmware/sdcard-pine64_ox64_full_defconfig.img of=/dev/sdb bs=1M status=progress conv=fsync

=== First Booting ===

Insert SD card into Ox64 and set a tty connection to Ox64 board
* Serial Console access:
* UART TX is physical pin 32/GPIO 16.
* UART RX is physical pin 31/GPIO 17.
* Baud 2000000.

minicom -b 2000000 -D /dev/ttyACM0

Re-Apply power to ox64

Enjoy the boot!

PS. To investigate running services
pstree | head -5
init-+-dhcpcd---3*[dhcpcd]
|-dropbear
|-klogd
|-login---sh-+-head
| `-pstree

[[Category:Ox64]] [[Category:Bouffalo BL808]]