Hold on to your hat, because this is going to be long.

Caveats

• These instructions are, specifically, for the Tannix TX3-Mini. However, with a bit of fiddling, the general approach should work for any supported TV Box. I have added notes where you will need to look to edit a different file for your specific device
• There are many, many variants of the TX3-Mini out there. What works for me, may not work for you. Do not expect any help or support from me, I am just posting this as a courtesy for how I got this working... your mileage may vary. I am not going to troubleshoot anyone's issues
• These instructions are quite verbose, as they may also help users of other TV Boxes to get their displays working. It also may not. Like I say, I am not here to be tech support, but we can all agree not having a display stuck on "boot" is a nice thing to have
• As this is a kernel module it will most likely stop working after each kernel update. You will probably want to create a DKMS to rebuild the module whenever you download a new kernel. This is outside of scope here. Use Google.
• At the end of this, if all goes well, you will have a display showing the current time. If you want to do more with the display then this is outside of scope and you will need to look elsewhere. However, this link is useful for how to trigger the icons: https://github.com/arthur-liberman/linux_openvfd/blob/master/led_control.txt (note: only items 1 to 6 are valid for the tx3-mini)
• A lot of this can be done in a chroot, but the actual building of the kernel module itself must be done on the target device. To simplify things all of these instructions are to be executed on the device itself. If you want to do this in a chroot, then knock yourself out, but you are on your own.

My setup

At the time of writing, these instructions are confirmed working for the 7 Segment display and all icons on:

• Tannix T3-Mini S905w with 2GB RAM
• Armbian 25.11
• Kernel 6.12.48-current-meson64
• Debian stable (trixie) (13)

Instructions

Note: Every code block here is meant to be pasted and executed in one go, even the multi-line blocks

We will work from the home folder to keep things simple. Don't worry, there will be no clutter as we will remove files we no longer require as we go

cd ~

Device Tree Blob
The first thing we are going to want to do is enable kernel support for openvfd in our DTB. Normally I'd do this with an overlay, but this does not appear to be enabled on the aml-s9xx-box image, so we will apply an overlay to the DTB directly:

• Install the device tree compiler:

  sudo apt install -y device-tree-compiler --no-install-recommends

• Back up the existing DTB (if anything goes wrong you can always just restore the backed up DTB) :
  Note: If your device is not a Tanix T3-Mini, then you will want to amend the following to point to the actual DTB you are using (you can find this in '/boot/extlinux/extlinux.conf')

  sudo cp /boot/dtb/amlogic/meson-gxl-s905w-tx3-mini.dtb /boot/dtb/amlogic/meson-gxl-s905w-tx3-mini.dtb.orig

   

• Create the overlay source code:

  cat << EOF > ~/openvfd.dts
  /dts-v1/;
  /plugin/;
  
  / {
      fragment@0 {
          target-path = "/";
          __overlay__ {
              openvfd {
                  compatible = "open,vfd";
                  dev_name = "openvfd";
                  status = "okay";
              };
          };
      };
  };
  EOF

• Compile the overlay:

  dtc -@ -I dts -O dtb -o ~/openvfd.dtbo ~/openvfd.dts

   

• Merge the overlay into your DTB:
  Note: If your device is not a Tanix T3-Mini, then you will want to amend the following to point to the actual DTB you are using

  sudo fdtoverlay -i /boot/dtb/amlogic/meson-gxl-s905w-tx3-mini.dtb -o /boot/dtb/amlogic/meson-gxl-s905w-tx3-mini.dtb ~/openvfd.dtbo

• Delete the overlay source:

  rm ~/openvfd.dts

• [Optional] Delete the compiled overlay:
  If your build is static (that is, you will never pull an updated DTB through apt) then you can also delete the compiled .dtbo overlay file. I prefer to keep this around, as you can just re-patch the new DTB with the "sudo fdtoverlay ..." command above. It is also possible to automate the update of a newly installed DTB file by creating a postinst.d script, but that is outside of the scope of this document. Google is your friend.

  rm ~/openvfd.dtbo

   

• Reboot so when we load the module later, our device knows what to do with it

  sudo reboot now

   

• Once your device has been rebooted, you can confirm that your change has been applied correctly with the following command:

  dtc -I fs -O dts /proc/device-tree | grep -A3 openvfd

  Again, this will generate a lot of warnings! This is normal. At the end of the warnings you should see the openvfd entry that you added to your DTS in the earlier step. If you do not, then you have not edited the file correctly, and you should go back and try again.

OpenVFD Config file

We need to create a configuration file which tells the OpenVFD module which GPIO pins are connected to the LCD display. We put this in the /etc folder as this is where we should be storing system configuration files for *deb based systems

The contents of this file were extracted from  https://github.com/arthur-liberman/vfd-configurations  so if you are using a different device, you must replace the following config with the relevant one from the link. If you are having issues with your config not working, direct them to the repo owner, not me. I do not know your device or what may be wrong.

Note: I remove the final functions='usb colon eth wifi' line as whilst the driver works fine with it included, it generates errors/warnings, which I would rather not see, and it appears to serve no purpose for Armbian

• Execute the following to generate the config for the TX3-Mini
  Note: If your device is not a Tanix T3-Mini do not execute the following. Instead, find your config at https://github.com/arthur-liberman/vfd-configurations and save it as /etc/openvfd.conf

  sudo bash -c "cat << 'EOF' > /etc/openvfd.conf
  vfd_gpio_clk='0,76,0'
  vfd_gpio_dat='0,75,0'
  vfd_gpio_stb='1,4,0'
  vfd_chars='4,3,2,1,0'
  vfd_dot_bits='0,1,3,2,4,5,6'
  vfd_display_type='0x01,0x00,0x00,0x00'
  EOF"

Build the Kernel Module

Now for the nitty gritty, we need to build the kernel module.

• The first thing we need is the kernel headers.
  Note: the headers version must match your installed kernel version exactly. Do not try installing the headers for a different kernel version. You will run into issues
  If you are on a standard image, or your kernel has been upgraded since you built your image, this is straightforward:

  sudo apt install linux-headers-$(uname -r)

  However, if you have built the image yourself, and you have not upgraded your kernel, then most likely the version available from the apt repository will not be compatible and your build may fail or the driver may not work at all. In these instances, you will need to go back to your build system and add the following switch to your ./compile.sh command:

  INSTALL_HEADERS=yes

   

• Install the required build tools

  sudo apt install -y git build-essential --no-install-recommends

   

• Clone the openvfd repo.
  At the time of writing the openvfd repo is not compatible with later Linux kernels. I have raised a PR against the repo to enable support, however it has not yet been accepted. If/when it is accepted I will be deleting my fork of the repo, but in the meantime, you can clone my fork with:

  git clone https://github.com/torzdf/linux_openvfd.git ~/linux_openvfd

  If the above does not work, it is because I have deleted my fork as the changes have been merged, and I am unable to come back and edit this post. If this is the case then run the following:
  Note: DO NOT run the next line, if the above git clone worked

  git clone https://github.com/arthur-liberman/linux_openvfd.git ~/linux_openvfd

   

• Enter the driver folder of the cloned repo

  cd ~/linux_openvfd/driver

   

• Create a Makefile. The provided Makefile will not work, so we need to replace it with our own:

  cat << 'EOF' > ./Makefile
  ifeq ($(KERNELRELEASE),)
  		PWD = $(shell pwd)
  	        KERNELDIR = /lib/modules/`uname -r`/build
  modules:
  	        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
  modules_install:
  	        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
  clean:
  	        rm -rf  *.o *.ko .tmp_versions *.mod.c modules.order  Module.symvers ssd253x-ts.*
  else
  		obj-m := openvfd.o
  		openvfd-objs += protocols/i2c_sw.o
  		openvfd-objs += protocols/i2c_hw.o
  		openvfd-objs += protocols/spi_sw.o
  		openvfd-objs += controllers/dummy.o
  		openvfd-objs += controllers/seg7_ctrl.o
  		openvfd-objs += controllers/fd628.o
  		openvfd-objs += controllers/fd650.o
  		openvfd-objs += controllers/hd44780.o
  		openvfd-objs += controllers/gfx_mono_ctrl.o
  		openvfd-objs += controllers/ssd1306.o
  		openvfd-objs += controllers/pcd8544.o
  		openvfd-objs += controllers/il3829.o
  		openvfd-objs += openvfd_drv.o
  endif
  EOF

   

• Compile the kernel module:

  make -j$(nproc)

   

• Install the kernel module:

  sudo make modules_install

   

• Update the kernel modules:

  sudo depmod -a

   

Create the helper service

Next we need to compile and install the helper service

• Enter the folder that contains the source code for the helper service:

  cd ~/linux_openvfd

   

• Build the helper service:

  make OpenVFDService

   

• Make the helper service executable:

  chmod +x OpenVFDService

   

• Install the helper service:

  sudo cp OpenVFDService /usr/bin/

Clean up

We have built everything we need from the OpenVFD repo, so we can get rid of the source code

• Go back to our home folder and delete the source code

  cd ~ && sudo rm -r linux_openvfd

   

systemd Service file

The final step. We need to create a service file that will load the kernel module, launch the helper service, and enable it on boot

• Create the systemd service file:
  note: If you prefer a 12 hour clock rather than a 24 hour clock, edit the 'Environment="OPTS=-24h"' line to 'Environment="OPTS=-12h"'

  sudo bash -c 'cat << '\''EOF'\'' > /etc/systemd/system/openvfd.service
  [Unit]
  Description=openvfd
  Wants=network-online.target
  
  [Service]
  Type=simple
  Environment="OPTS=-24h"
  ExecStartPre=/usr/bin/sh -c ". /etc/openvfd.conf; /usr/sbin/modprobe openvfd vfd_gpio_clk=$vfd_gpio_clk vfd_gpio_dat=$vfd_gpio_dat vfd_gpio_stb=$vfd_gpio_stb vfd_chars=$vfd_chars vfd_dot_bits=$vfd_dot_bits vfd_display_type=$vfd_display_type;"
  ExecStart=/usr/bin/OpenVFDService $OPTS &
  ExecStop=/usr/bin/killall OpenVFDService
  ExecStopPost=-/usr/sbin/rmmod openvfd
  
  [Install]
  WantedBy=multi-user.target
  EOF'

   

• Reload the systemd daemon:

  sudo systemctl daemon-reload

   

• Start the openvfd service:

  sudo systemctl start openvfd.service

  At this point your LCD should now be showing the time. If it is not, you can check for errors with:

  sudo systemctl status openvfd.service

   

• Enable the service at boot:

  sudo systemctl enable openvfd.service

   

And that's it. If all has gone well, you now have a working LCD Display for your TV Box running a recent Armbian build

sudo apt install -y smplayer alsa-base alsa-oss alsa-tools alsa-utils alsamixergui pulseaudio pavucontrol pavumeter

You can use smplayer or vlc or another as long as it is modern media player or audio player. Now make a backup copy of these two text files /etc/modules and /etc/modprobe.d/alsa-base.conf and save the backup copies in your home directory.

Without quotes, edit the text file /etc/modules and write “snd-usb-audio” at the end of the file. Also, edit the text file /etc/modprobe.d/alsa-base.conf and change a few things.

Put a hash # symbol in front of every “options snd-usb-audio index=-2” that you see in the file /etc/modprobe.d/alsa-base.conf . I found two of them. Add these two lines of text to the bottom of /etc/modprobe.d/alsa-base.conf without quotes.

"alias snd-card-0 snd-usb-audio"

"options snd-usb-audio index=0"

Make sure that your user is in the 'audio' group. Run the usermod command against a regular user (not root) that you want to use often. And reboot.

sudo usermod -a G audio {username here}

sudo reboot 

Login to the graphical desktop, open the volume control program by clicking on the panel Applications, Multimedia, PulseAudio Volume Control. Click the Configuration tab at the far right of the volume control program and change the profile to Analog Stereo. * Important – now connect a headset, earphone, or amplifier to the 3.5mm (⅛’’) 🎧 headphone receptacle on the USB audio dongle and play some sounds, music or youtube. You can use wav audio files in the directory /usr/share/sounds/alsa/ if you don't have an internet connection.

Here is a tutorial to recover this box and the steps may also work for other tv boxes that have the S905x / S905x2 / S905x3 chip.

Download Amlogic Burn Card Maker v2.0.3 (not other versions) from Here or Here.

Download stock android firmware T95MAXplus-X3-9.0-2GB4GB-6330-0720-20200616-Android.rar from Here or the same firmware but as img a file from MEGA

Unpack the archive file in 7zip, if you have the rar file. But there is no unpacking to do if you have the img file.

Insert a new good micro-SD memory card into the SD card adapter, and plug it into your PC
- be sure there is only one single partition on the SD memory card formatted as FAT32

Run the 'Burn_Card_Maker.exe' executable file. Make sure it is version 2.0.3

Change language to English if it is not already in that:

 - Click on the Chinese menu (or garbled text menu) in the upper-left corner, and choose the second option.

 - Dialog screen appears and now simply select 'English Version' and click OK button.

Select your SD memory card drive letter under 'Choose Disk:'
 - you may need to use Disk Management in Windows and apply a drive a letter to the SD memory card.

Check mark the Yes box on under 'To Partition and Format' or tick the box 'Formatting SD card'
- a new menu pane will popup. follow through and format the SD memory card.

Check mark the Yes box on under the Normal SD bootloader for Erase Bootlooader

Check mark the Yes box on under the Erase Flash for Normal Flashing

Do NOT check mark the Yes on (click to Uncheck it) under 'reboot'.

Click 'Open' button under 'Select Burn Package f:' and select the factory stock Android file T95MAXplus-X3-9.0-2GB4GB-6330-0720-20200616.img
- make sure there are no spaces in the file name of the img

Last step in Burn_Card_Maker: Press 'Make' button and wait to finish.

Go to the TV box. Disconnect the power cable from the tv box device. Then insert the micro SD memory card in your tv box device and power on the device. If it didn't boot at all, the you may need to use the toothpick method. Disconnect power cable again. Put a toothpick into the audio jack, press and hold the reset button while you insert the power cable. The tv box will enter into recovery and the firmware will be flashed automatically. Be patient and wait up to 10 minutes. After the TV BOX fully starts, remove the micro SD Card. and the update will completed. The T95 Max (whatever it is) graphic logo will appear and stock Android 9 will start.

Table of Contents

1. check dtb
2. burn Armbian to SD card
3. configure boot partition
4. install Armbian on SD card
5. flashing
   1. install-aml.sh script
   2. Amlogic USB Burning Tool
   3. Amlogic Burn Card Maker Tool
   4. SHORT PIN method
   5. Team Win Recovery Project
6. software
   1. install docker
   2. install openWRT
   3. install pi-hole
   4. install portainer
   5. install RPi monitor
   6. install xfce
   7. install midori browser
   8. install full armbian firmware
   9. install USB LTE dongle
7. backup SD card
8. armbian commands
9. android stock firmware

check dtb

1. Install Device Info HW and open the app
2. In the "SYSTEM" tab, you can find the "dtb" information for your box. This information is crucial for configuring the boot partition correctly. Please keep a note of your "dtb" (device tree blob) information for future boot partition configuration.

burn Armbian to SD card

1. Mare sure to use good, reliable and fast SD card from SandDisk, class 10, A1
2. Choose between ubuntu (jammy) and debian (bookworm) and download .xz file compressed image from the official Armbian archive. For advanced linux users who want a clean server (not even includes armbian-config), the "minimal" variant is recommended.
3. Download burning tool balenaEtcher or USBImager and burn the compressed image to your SD card.

https://docs.armbian.com/User-Guide_Getting-Started/

configure boot partition

1. Open extlinux/extlinux.conf and uncomment the correct dtb for your box. If you make a mistake here, you will fail to boot. Make sure only one line is uncommented (check your dtb, for s912 SoC its q200 or q201).
2. Go back to armbi_boot partition, copy the correct u-boot file according to your SoC and rename it to u-boot.ext. If you dont know your SoC, boot into Android, install/open Device Info HW app and go to SOC tab. The app may need root access to read device specs.

install Armbian on SD card

To boot the system for the first time you have to use one from the following - sometimes only one way of doing this works! If your box is installed with libreElec/coreElec, then you can't boot into Armbian, because you have to flash stock Android firmware first.

• Toothpick method: disconnect the power supply, insert card/drive, push reset button and connect the power while holding the button. Wait until Armbian logo appears and release the button.
• Terminal method: boot to Android, insert SD card with Armbian, install Terminal Emulator app (either from Google Play or APKMirror), run it and type reboot update. Your box should reboot to Armbian.
• Update&Backup: somewhere in the Android interface, perhaps the applications folder, you will find a program called Update OR Update&Backup, open it if you have "Update" app pre-installed, insert SD card with Armbian, select "Local" and choose ZIP file (aml_autoscript.zip) from the SD card; select "Update" and your box should reboot to Armbian.
• Recovery method: boot into Android, insert card/thumb drive and choose Reboot to recovery. Your box should boot into Armbian.
• ADB method: enable ADB (Google it) and run the following command in a terminal window: adb reboot update
• Menu button method (works with very few devices): disconnect the power supply, insert card/drive, push menu button on your remote control and connect the power while holding the button. Wait until Armbian boot script appears and release the button.

install-aml.sh script

NOTE: This will overwrite the Android ROM on the eMMC flash and attempt to install Armbian on the internal eMMC storage. Before beginning, make sure you have a backup of the stock Android ROM in the event the installation fails or you want to revert back to Android in the future. Proceed at your own risk.

You can copy the working Armbian environment from SD card to eMMC using the install-aml.sh script. This file does a physical copy of whole system to eMMC. You can install Armbian to eMMC by running the shell script in the /root directory. Run the following commands in a terminal window:

sudo su
cd /root/
sudo ./install-aml.sh 

Once the Armbian finishes copying to the eMMC, shutdown Armbian, unplug power from the box, remove the SD card from the box, power the box back on to boot from the eMMC storage, if everything worked as expected, Armbian should boot from the internal eMMC storage and no longer require the SD/microSD card.

Amlogic USB Burning Tool

If you have a box with an Amlogic processor and need to update its firmware, install a custom ROM, or unbrick the box, the Amlogic USB Burning Tool is the recommended solution. It provides an easy-to-use interface for flashing firmware onto Amlogic-based devices. To use the Amlogic USB Burning Tool, follow these steps:

1. Download the Amlogic USB tool zip file and extract it to the PC.
2. In the folder, you have the InstallDriver.exe. This will install the required drivers for Amlogic TV boxes.
3. Download the firmware file compatible with your box.
4. Launch the Amlogic USB Burning Tool, change language and click “File” > “Import Image” to load the firmware file.
5. Connect your box to your PC using a USB cable, ensuring the box is in recovery mode (toothpick method) or bootloader mode.
6. The tool should detect your box, and you can click the “Start” button to begin the flashing process.
7. Wait for the process to complete, and your box will reboot with the new firmware installed.

Amlogic Burn Card Maker Tool

With this method you can recover the device from a brick if you have no way to connect it to a PC. In this tutorial, we will guide you on using the burn card maker tool to create a bootable SD card for reinstalling Android Stock Firmware (ROM) on your box. You just need the correct firmware (ROM) for your specific box.

1. Download Burn_Card_Maker v2.0.2 (3.96 MB).
2. Extract the archive and run Burn_Card_Maker.exe file to run the tool.
3. Click on upper left chinese menu and choose second option, check ‘English Version’ and restart the application.
4. Choose disk then ‘Choose your image files’ to open image and select your specific .img firmware for your box.
5. Press ‘Make’ button and wait to finish. Now insert the micro SD card in your box and power on while holding the reset AV button. You will be able to enter into recovery and the firmware will be flashed automatically. When the TV BOX reboots, remove the micro SD Card, this step is very important, wait 4-5 minutes and the update will completed.
6. If your device fails to boot, your last option is to use the SHORT PIN method.

SHORT PIN method

Follow the steps outlined in the guide Amlogic Burn Card Maker Tool. If pressing the AV reset button doesn't work, it is likely that your device is unresponsive or "dead". In this case, you can try shorting out the PINS. Please note that at this point, you have little to lose in terms of further damage to the device. The SHORT PIN method can be used when other recovery methods and the Amlogic USB Burning Tool are not responsive. Please note that this method should only be attempted by those who fully understand the risks involved in handling electronics and take full responsibility for any potential issues that may arise.

1. Dismantle: to proceed with the SHORT PIN method, you will need to dismantle your device. Remove the rubber placeholders on the back of the device to reveal screws. Unscrew these screws and carefully separate the device. Be cautious when removing the top part of the device, as the WIFI antenna is usually attached to it. Removing it too quickly may cause damage to the WIFI cable.
2. NAND flash: locate the NAND flash chip, which is where the operating system is stored. Look closely at the PINS on the chip, as they are quite small. Identify two pins that are next to each other, and using a screwdriver, short them out by making them touch each other.
3. Recovery menu: ensure that your SD card is inserted with the firmware image using the Burn Card Maker tool. Have your power supply and HDMI cable ready to be inserted. Now, slowly try different combinations of the PINS while applying power to the device. Eventually, you will find a combination that initiates the hardware and communicates with the SD card. This will initiate the boot sequence, and you should see a recovery menu on the screen. From there, the installation of Android will begin. Essentially, shorting out these two PINS is similar to holding the AV reset button.
4. Again: Before applying power, hold down the two PINS and then apply power. Repeat this process until you see results or something on the screen. Sometimes, the screen may flash green or red, indicating that you have found the correct PINS but have the wrong firmware. In this case, return to your PC and find a different firmware image specific to your SoC. If you are unable to find the original stock ROM for your box, it is possible that your box is a clone of another well-known box. In this case, find the firmware for the box that is most closely related to yours.

You need to make your box boot once into recovery/update mode to reinstall firmware from SD card. The SHORT PIN method modifies normal boot procedure to make your box look for kernel and dtb on SD card before booting from internal memory.
https://inv.vern.cc/watch?v=CUfKNNgxb9E

Team Win Recovery Project

TWRP, short for Team Win Recovery Project, is a community-driven project that provides a custom recovery solution for Android devices. It supports backups, restoration, and custom ROM installation.
https://twrp.me/Devices/

install docker

ubuntu

Add the GPG key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 

Add repository to APT sources:

sudo add-apt-repository "deb [arch=$(dpkg --print-architecture)] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
apt-get update

Install Docker:

apt-get install docker-ce docker-ce-cli containerd.io 

Test the installation:

docker --version 

Install Docker Compose:

sudo curl -L "https://github.com/ubiquiti/docker-compose-aarch64/releases/download/1.22.0/docker-compose-Linux-aarch64" -o /usr/local/bin/docker-compose<br>
sudo chmod +x /usr/local/bin/docker-compose

Test Docker Compose installation:

docker-compose --version 

debian

apt-get remove docker docker-engine docker.io containerd runc
apt-get install ca-certificates curl gnupg lsb-release
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
apt update
apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin 

If you would like to use Docker as a non-root user, you should now consider adding your user to the docker group with something like:

sudo usermod -aG docker $USER 

https://docs.armbian.com/User-Guide_Advanced-Features/#how-to-run-docker

install openWRT

On the host system, the full armbian firmware should be installed so you can use it on AP mode:

wget https://imola.armbian.com/apt/pool/main/a/armbian-firmware-full/armbian-firmware-full_21.08.6_all.deb
sudo dpkg -i armbian-firmware-full_21.08.6_all.deb 

Make sure your USB WIFI adapter supports AP mode:

iw list 

Set country regulations, for example, to Spain set:

iw reg set ES 

Make sure you are not runing wpa_supplicant on your host machine or docker container will tell messages like wlan0: Could not connect to kernel driver.

sudo systemctl stop wpa_supplicant
sudo systemctl disable wpa_supplicant 

Install dependencies:

sudo apt install iw iproute2 gettext dhcpcd5 

Initial configuration is performed using a config file, openwrt.conf. You can use the included openwrt.conf.example as a baseline, which explains the values. At the very least you’ll need to change the values of LAN_PARENT and WIFI_IFACE. Commands to download the repo and configure openwrt.conf

git clone https://github.com/oofnikj/docker-openwrt.git
cd docker-openwrt
cp openwrt.conf.example openwrt.conf
nano openwrt.conf 

Build the image:

make build 

Create the openwrt container:

make run 

If you arrive at * Ready, point your browser to LAN_DOMAIN and you should be presented with the login page. The default login is root with the password set as ROOT_PW. Any settings you configured or additional packages you installed will persist until you run:

make clean 

This will delete the container and all associated Docker networks so you can start fresh if you screw something up.

Installing will create and enable a service pointing to wherever you cloned this directory and execute run.sh on boot.

make install

https://forum.openwrt.org/t/running-openwrt-in-a-docker-container/56049
https://badgateway.qc.to/contain-your-router/
https://github.com/oofnikj/docker-openwrt

install pi-hole

Start by creating a directory where you will store the configuration file for the Pi-Hole docker container:

mkdir pihole
cd pihole
nano docker-compose.yml

Enter the following lines:

services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "67:67/udp"
      - "80:80/tcp"
    environment:
      TZ: 'Europe/Berlin'
      WEBPASSWORD: '1234'
    networks:
      internal:
        ipv4_address: 192.168.16.10  # Assign a static IP within your router's subnet
    volumes:
      - './etc-pihole:/etc/pihole'
      - './etc-dnsmasq.d:/etc/dnsmasq.d'
    cap_add:
      - NET_ADMIN
    restart: unless-stopped
    networks:
      openwrt-lan:
        ipv4_address: 192.168.16.10  # Assign a static IP within your LAN subnet
networks:
  openwrt-lan: 

If you are using ubuntu to run the pi-hole docker container, you may need to disable the systemd-resolve service:

systemctl disable systemd-resolved.service
systemctl stop systemd-resolved

Then, you can bring your pi-hole up:

docker-compose up -d

As we managed our own router firmware using OpenWrt, you need to tell your router to send pi-hole IP as DNS server to client. Go to Interfaces -> Lan -> DHCP Server -> Advanced Settings, inside DHCP-Options enter value: 6,192.168.16.10. Apply changes and restart the LAN interface.

https://pimylifeup.com/pi-hole-docker/

https://firebog.net/

https://arstech.net/pi-hole-blocking-lists-2023/

https://avoidthehack.com/best-pihole-blocklists

install portainer

docker volume create portainer_data
docker run -d -p 8000:8000 -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data --network=openwrt-lan portainer/portainer-ce 

install xfce

sudo apt-get -y install xorg lightdm xfce4 tango-icon-theme gnome-icon-theme dbus-x11
sudo startxfce4 

To disable the desktop environment and return to tty1 after installing xfce on Armbian, you can follow these steps:

1. Press Ctrl + Alt + F1 to switch to tty1.
2. Log in with your username and password.
3. Stop the display manager service by running the following command:

   sudo service lightdm stop

   This will stop the graphical interface and return you to the command line interface. To prevent the display manager from starting automatically on boot, run the following command:

   sudo systemctl disable lightdm

    

install midori browser

sudo apt install midori 

install RPi monitor

The RPi monitor on port 8888 can also be installed for AMLOGIC boxes with the following command:

sudo armbianmonitor -r

install full armbian firmware

By default, the Armbian builds only include a limited set of firmwares out of the box. To address certain driver issues, you may need to install the complete Armbian firmware. There are two ways to do this: either through armbian-config -> software -> Full, or by manually installing the firmware via a USB device if you don't have internet connectivity on your box. To manually install the firmware, download it from the following link: https://imola.armbian.com/apt/pool/main/a/armbian-firmware-full/. Once downloaded, copy the firmware to your USB device. Then, insert the USB device into the Armbian box and navigate to your home folder.

cd ~ 

Check device identifier of your USB device:

lsblk 

Mount USB device at ./usbstick and install the package:

mkdir usbstick
sudo mount /dev/sdX1 ./usbstick
cd usbstick
dpkg --install armbian-firmware-full_*.deb

Replace sdX1 with your device identifier.

install USB LTE dongle

Armbian has a default setting that treats USB LTE Dongles as mass storage devices. However, in order for the dongle to be recognized as an Ethernet device, it needs to be switched from mass storage mode to network mode. To achieve this, we will need to install and configure usb-modeswitch.

sudo nano /etc/usb_modeswitch.conf 

Paste the following:

# Huawei E353 (3.se) and others
TargetVendor=0x12d1
TargetProductList="14db,14dc"
HuaweiNewMode=1
NoDriverLoading=1 

Install usb-modeswitch:

sudo apt-get update
sudo apt-get install usb-modeswitch 

Switch dongle to network mode:

sudo usb_modeswitch -v 12d1 -p 1f01 -c /etc/usb_modeswitch.conf 

You can now check if mass storage is removed:

lsusb 

https://askubuntu.com/questions/757638/can-not-connect-huawei-e3372-modem-on-ubuntu-15-10-please-help
https://installati.one/install-usb-modeswitch-ubuntu-20-04/

armbian commands

Configure system, network, timezone, language, hostname, keyboard, etc:

armbian-config 

Check temperature of SoC:

armbianmonitor -m 

Get boot logs for inspection and automatically upload it to an online pasteboard service:

armbianmonitor -u

backup SD card

1. Identify the SD Card: First, you need to identify the device name of your SD card. You can use the lsblk or fdisk -l command to list all storage devices and identify the SD card.
2. Backup with dd: Use the dd command to create a raw image of the SD card. Here's an example command:

   sudo dd if=/dev/sdX of=/path/to/backup.img bs=4M status=progress

   Replace /dev/sdX with the actual device name of your SD card and /path/to/backup.img with the desired backup location and filename.
3. Restoring from Backup: To restore the backup to a new SD card, you can use either balenaEtcher or a similar command in reverse:

   sudo dd if=/path/to/backup.img of=/dev/sdX bs=4M status=progress

    

android stock firmware

x96

Tanix

Ugoos

Vontar

Mecool

You can copy the working Armbian environment from SD card/USB drive to eMMC using the install-aml.sh script. This file does a physical copy of whole system to eMMC. You can install Armbian to eMMC by running the shell script in the /root directory. Run the following commands in a terminal window:

sudo su
cd /root/
sudo ./install-aml.sh

Once the Armbian finishes copying to the eMMC, shutdown Armbian, unplug power from the box, remove the SD card/USB drive from the box, power the box back on to boot from the eMMC storage, if everything worked as expected, Armbian should boot from the internal eMMC storage and no longer require the SD/microSD card.

https://github.com/kdrapel/x96mini_linux/blob/main/README.md

----

Installing Linux on X96 Mini

Goal is to install a Linux on a X96 Mini that I did not use anymore as a TV box and wanted to recycle as a DNS server for ads-blocking (https://pi-hole.net/) and other experiments.

Important: I will not give any support or answer questions related to issues happening with your own X96

Prerequisites

Instructions are covering steps on a Windows machine. Should be similar for Linux. Based upon (messy) instructions found at https://forum.armbian.com/topic/12162-single-armbian-image-for-rk-aml-aw-aarch64-armv8/

Hardware

• X96 Mini 2GB CPU is S905X. Label behind say "X96 mini RAM 2GB, ROM 16 GB".
• SD card, 16 GB. Smaller will be ok too (needs at least 8GB)
• Toothpick or small stick (reset button inside AV jack)

Software

• Rufus 3.12
• 7Z

Preparation

• Download https://users.armbian.com/balbes150/arm-64/Armbian_20.10_Arm-64_focal_current_5.9.0.img.xz
• Unzip this file to get Armbian_20.10_Arm-64_focal_current_5.9.0.img
• Launch Rufus, select the img. Click on 'Start'. SD card will be formatted and content will be written.

Configuration of u-boot

In Windows Explorer, navigate to your SD card. You should see a structure a 'extlinux' folder, 'dtb', etc.

Rename the file 'u-boot-s905x-s912' to 'u-boot.ext'

Configuration of device tree block

A Device Tree Block (DTB) is a file that contains important information about the target hardware (more info http://junyelee.blogspot.com/2015/07/a-tutorial-on-device-tree.html). So it is necessary to use the proper one. This is a tricky part and if an improper DTB is used, your target system will fail loading or the kernel will panic.

• Edit the file /extlinux/extlinux.conf
• Comment out all lines starting with FDT and APPEND (we don't want RK or AW configuration, we are only interested in AML s9xxx section).
• Uncomment 'FDT /dtb/amlogic/meson-gxl-s905x-p212.dtb' and 'APPEND ....'. See example below

LABEL Armbian
LINUX /zImage
INITRD /uInitrd

# rk-3399
#FDT /dtb/rockchip/rk3399-rock-pi-4.dtb
#FDT /dtb/rockchip/rk3399-nanopc-t4.dtb
#FDT /dtb/rockchip/rk3399-roc-pc-mezzanine.dtb
#APPEND root=LABEL=ROOTFS rootflags=data=writeback rw console=uart8250,mmio32,0xff1a0000 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0

# rk-3328
#FDT /dtb/rockchip/rk3328-roc-pc.dtb
#FDT /dtb/rockchip/rk3328-box-trn9.dtb
#FDT /dtb/rockchip/rk3328-box.dtb
#APPEND root=LABEL=ROOTFS rootflags=data=writeback rw console=uart8250,mmio32,0xff130000 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0

# aw h6
#FDT /dtb/allwinner/sun50i-h6-tanix-tx6.dtb
#APPEND root=LABEL=ROOTFS rootflags=data=writeback rw console=ttyS0,115200 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0 video=HDMI-A-1:e
#APPEND root=LABEL=ROOTFS rootflags=data=writeback rw console=ttyS0,115200 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0 mem=2048M video=HDMI-A-1:e

# aml s9xxx
#FDT /dtb/amlogic/meson-gxbb-p200.dtb
FDT /dtb/amlogic/meson-gxl-s905x-p212.dtb
#FDT /dtb/amlogic/meson-gxm-q200.dtb
#FDT /dtb/amlogic/meson-g12a-x96-max.dtb
#FDT /dtb/amlogic/meson-g12b-odroid-n2.dtb
APPEND root=LABEL=ROOTFS rootflags=data=writeback rw console=ttyAML0,115200n8 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0

Launching

• Unplug the X96 Mini
• Insert the SD card
• Using a toothpick, small stick or whatever suitable, press on the 'reset' switch which is located inside the AV jack. You don't need to press too hard.
• While the reset switch is maintained pressed, plug the power. The X96 Mini screen will appear and normally after a few seconds, it should switch to the Linux boot.
• You can release the reset switch. Linux should run if everything is properly configured.
• I access it through SSH on port 22. It is of course recommended to change the default root password (root / 1234)

Installing Pi-Hole on the X96

Upgrading system

• First upgrade your system with "apt-get upgrade"
• About 50 packages or so are upgraded.

Install Pi-Hole

It may fail by saying that your OS is not supported, just follow the instructions they provide in the error message in this case. I will not detail the complete installation, I used the default configuration step without doing any tweaking except giving the target IP address of my X96 on my network.

curl -sSL https://install.pi-hole.net | PIHOLE_SKIP_OS_CHECK=true sudo -E bash

Configuration of router

• Assign a static IP to the MAC address of your X96. This must match what you defined in the PI-hole configuration.
• Switch the router to your new DNS server (as the primary). I left the secondary DNS server to my ISP default, just in case the X96 crashes or fails for whatever reason.

Smoke testing

• Disable ad-blocking in your browser and navigate to some heavy websites 
• Additional lists may be useful for Youtube adblocking, here is my configuration. 

Known issues

Wifi is not working. I did not investigate more as I don't need it right now. Probably some (proprietary) Realtek drivers are needed from what I have read on the web.

Troubleshootings

You can attach a keyboard and mouse to the USB ports. The Logitech receiver is also working such that I could use my keyboard.

Greetings,
NicoD