WiFi 7 Adapters on JetPack 7.2

Commercial packaging for WiFi 7 (802.11be) adapters promises “driver-free” setup and multi-gigabit speeds. On a Jetson Orin running JetPack 7.2, plugging one in usually yields no network interface at all, or mounts a virtual CD-ROM containing a Windows installer.

NVIDIA’s L4T kernel ships no out-of-tree Realtek USB WiFi drivers. Ubuntu 24.04 packages firmware with Zstandard compression, but the Tegra kernel cannot decompress it. Headless SSH sessions block standard connection commands without administrative privileges.

This guide details the platform constraints, compares USB against PCIe options, and walks through a verified deployment of a Realtek RTL8912AU adapter on JetPack 7.2 (6.8.12-1021-tegra).

Hardware identification: probe before build

Do not guess the driver requirement from the retail box or marketing sheet. Manufacturers routinely ship entirely different silicon revisions under the identical product SKU.

Inspect live bus enumeration to determine the exact silicon:

Dual-mode USB bus anchoring (SuperSpeed switch)

Realtek RTL8922AU/8912AU silicon (and BE-class Realtek USB adapters generally) is dual-mode: the same dongle enumerates as full-speed on the USB 2.0 fallback path (Bus 001 at 480M) or SuperSpeed on Bus 002 at 5000M depending on which host port it occupies. This is not user-visible at plug time, but it caps the host transfer rate: a 480M anchor soft-limits real throughput at about 400 Mbit/s regardless of the radio’s negotiated PHY rate.

The morrownr rtw89 driver performs the mode switch for you at module load — rtw89_usb_switch_mode_be() runs as part of probe when the module parameter switch_usb_mode is Y (default), programs the pad controller for a SuperSpeed transition, and the device re-enumerates onto the SuperSpeed bus — but only if it is plugged into a port routed to Bus 002. Verify the anchoring, not the descriptor:

lsusb -t
# Look for the adapter's line:
# Port 002: Dev 008, If 0, Class=Vendor Specific Class, Driver=rtw89_8922au_git, 5000M

• 480M (Bus 001): anchored to the USB 2.0 fallback path. Re-plug into a SuperSpeed-routed port and reload the module.
• 5000M (Bus 002): mode switch engaged, USB bus no longer the bottleneck.

Do not conclude the adapter is “USB 2.0-only” from its descriptor (bcdUSB 0x0200 is what a dual-mode adapter reports while running as high-speed): the empirical lsusb -t check after replug is the definitive verification.

# For USB adapters
lsusb

# For PCIe / M.2 Key-E modules
lspci -nnk

The “BE6500” silicon decision matrix

“BE6500” is an aggregate marketing bandwidth rating (~6.5 Gbps across bands), not a chipset. Retail BE6500 adapters ship with three distinct silicon architectures:

Form factor choice: USB vs PCIe

The JetPack 7.2 platform gotchas

Before compiling any driver on JetPack 7.2 (6.8.12-1021-tegra), understand these platform boundaries:

1. The firmware compression gap

Ubuntu 24.04 (noble) packages firmware using Zstandard (.zst) compression to conserve disk space. Under /lib/firmware/rtw89/, the firmware files carry the .bin.zst extension.

NVIDIA’s kernel configuration for 6.8.12-1021-tegra leaves firmware compression unset (# CONFIG_FW_LOADER_COMPRESS is not set). The kernel lacks a built-in decompression routine for firmware loading.

When the driver calls request_firmware(&fw, "rtw89/rtw8922a_fw-4.bin", dev), the kernel searches the filesystem for that literal string. Because only rtw8922a_fw-4.bin.zst exists, the VFS returns -ENOENT (Error -2):

Direct firmware load for rtw89/rtw8922a_fw-4.bin failed with error -2
rtw89_8922au_git 1-2:1.0: failed to setup chip information

To fix this, decompress the binary manually:

sudo apt-get install -y zstd
sudo zstd -d /lib/firmware/rtw89/rtw8922a_fw-4.bin.zst -o /lib/firmware/rtw89/rtw8922a_fw-4.bin

Seeed Studio’s official JetPack 7.2 WiFi repair script (fix_wifi.sh) contains an identical decompression pass across /lib/firmware/, independently confirming that this is an L4T platform-wide limitation affecting both USB and PCIe cards.

Intel cards follow the same two-file rule: iwlwifi rejects an AX210/AX200 unless both the .pnvm and the matching .ucode are present, so decompress both from their .zst copies:

cd /lib/firmware
sudo zstd -d iwlwifi-ty-a0-gf-a0.pnvm.zst
sudo zstd -d iwlwifi-ty-a0-gf-a0-*.ucode.zst

2. Clean in-tree driver slate (CONFIG_RTW89=n)

On desktop Linux, out-of-tree drivers frequently collide with distribution-provided drivers (rtw89_core, rtw88). On JetPack 7.2, NVIDIA compiles the Tegra kernel with Realtek wireless disabled (CONFIG_RTW89=n). The out-of-tree module binds directly to the device without requiring modprobe blacklist configurations.

3. Module signing and kernel taints

CONFIG_MODULE_SIG_ALL=y is set, but NVIDIA does not distribute signing_key.pem in public headers. Plain make produces unsigned .ko binaries. Check what the running kernel actually enforces before deciding what to do:

zcat /proc/config.gz | grep CONFIG_MODULE_SIG

• # CONFIG_MODULE_SIG_FORCE is not set (the JetPack 7.2 default): an unsigned module loads and the kernel records taint bits 4096 (out-of-tree) and 8192 (unsigned) in /proc/sys/kernel/tainted. Taint records a load that already happened; it never waives a check that is about to happen.

• CONFIG_MODULE_SIG_FORCE=y: unsigned modules are rejected at load time. Sign them with a trusted key:

  # Template only — each <...> is a placeholder, not a literal path.
  # Replace all three with your key, your certificate, and the built module.
  /lib/modules/$(uname -r)/build/scripts/sign-file sha512 <signing-key.pem> <signing-cert.der> <module>.ko

  The sign-file helper ships in the headers tree (resolves via the build symlink); the key and certificate do not. This kernel sets # CONFIG_SECONDARY_TRUSTED_KEYRING is not set, so there is no runtime path to enroll your own certificate: the module must be signed with the kernel build key, or the kernel rebuilt with yours.

Avoid running automated DKMS signing steps until you verify the manual build loads cleanly.

4. Package upgrade danger

sudo apt-mark hold nvidia-l4t-*

Step-by-step walkthrough: BE6500 USB adapter (Realtek RTL8912AU)

Follow this verified sequence to bring up a representative BE6500 USB adapter (tested on a DE-BE6500 unit with Realtek RTL8912AU silicon) on an NVIDIA Jetson Orin Nano Developer Kit running JetPack 7.2 (6.8.12-1021-tegra).

Step 1: Handle multi-state CD-ROM trap (if needed)

If lsusb shows 0bda:1a2b, install usb-modeswitch and force usb-storage to ignore the installer virtual disc:

sudo apt-get install -y usb-modeswitch
echo "options usb-storage quirks=0bda:1a2b:i" | sudo tee /etc/modprobe.d/usb_storage.conf
sudo update-initramfs -u

Unplug and reconnect the adapter. The quirk suppresses the storage claim; the adapter still needs the mode switch itself. Pass -K (--std-eject) so usb_modeswitch sends a standard eject sequence, which triggers switching to the network product ID on the tested adapter:

sudo usb_modeswitch -K -v 0bda -p 1a2b

lsusb should now display 0bda:8912 (or 0bda:8922). Confirm the re-enumeration in dmesg (look for the disconnect/reconnect pair).

Step 2: Install toolchain and headers

sudo apt-get update
sudo apt-get install -y build-essential git dkms zstd linux-headers-$(uname -r)

Verify the build tree symlink:

ls -ld /lib/modules/$(uname -r)/build
# Should point to /usr/src/linux-headers-6.8.12-1021-tegra

Step 3: Clone and compile morrownr/rtw89

The morrownr/rtw89 driver tree builds out-of-tree modules with a _git suffix (such as rtw89_8922au_git.ko) to avoid colliding with in-tree kernel drivers:

git clone https://github.com/morrownr/rtw89.git
cd rtw89
make clean
make -j$(nproc)

Step 4: Install modules

sudo make install
sudo depmod -a

For DKMS-managed persistence across kernel updates, the README’s documented invocation registers the cloned tree directly:

sudo dkms install "$PWD"

If DKMS stops at the signing step (see the signing section above), fall back to the manual make install path and prove the unsigned build loads before re-attempting DKMS.

Step 5: Decompress firmware and load module

If /lib/firmware/rtw89/ holds no rtw8922a_fw-*.bin.zst at all, install the firmware set first from the cloned rtw89 tree:

sudo make install_fw

Then decompress the primary firmware and fallback versions into raw .bin format:

sudo sh -c 'cd /lib/firmware/rtw89 && for f in rtw8922a_fw-4.bin rtw8922a_fw-3.bin rtw8922a_fw-2.bin rtw8922a_fw-1.bin rtw8922a_fw.bin; do [ -f "$f" ] || zstd -d -q "${f}.zst" -o "$f"; done'

Load the module:

sudo modprobe rtw89_8922au_git

Verify in kernel logs:

journalctl -k --no-pager | grep rtw89_8922au_git | head -5

The output should confirm successful initialization:

kernel: rtw89_8922au_git 2-1.2:1.0: firmware: direct-loading firmware rtw89/rtw8922a_fw-4.bin
kernel: rtw89_8922au_git 2-1.2:1.0: Broadcom/Realtek WiFi 7 Controller initialized

Step 6: Connect and resolve headless Polkit authorization

Verify that the network interface appears (typically wlan1 or wlx... if an onboard M.2 wireless card is already present, or wlan0 if the USB adapter is the sole wireless device):

ip link show
nmcli dev wifi list

sudo usermod -aG netdev $USER

Connect to your wireless network:

sudo nmcli dev wifi connect "YourNetworkSSID" password "YourPassword"

Step 7: Dual-radio coexistence and benchmarking

If your Jetson has an onboard M.2 card (rtl88x2ce on wlan0), the new USB adapter operates on wlan1. The two PHY devices (phy0 and phy1) run concurrently without driver conflict. If your carrier board does not include an internal M.2 wireless card, the USB adapter claims wlan0 as the sole wireless interface, and multi-radio coexistence is not required.

The socket binding methodology: SO_BINDTODEVICE

Disconnecting interfaces to isolate traffic introduces two major hazards: it drops your routing tables and severs your SSH session if your console connection rides the disconnected interface.

Instead, pin client traffic per interface using socket-level device binding. iperf3 -B <IP> alone binds only the socket’s source address — pass --bind-dev <interface> as well for the real SO_BINDTODEVICE semantics (requires iperf 3.16+ and CAP_NET_RAW, so prefix with sudo where needed):

Install iperf3 on both the Jetson under test and the server host first — Ubuntu 24.04 (noble) ships iperf 3.16, which includes --bind-dev, so the archive package is enough (confirm with iperf3 --version):

sudo apt-get install -y iperf3

# On the target iperf3 server (for example, a wired host or secondary node on the local subnet):
iperf3 -s

# On the Jetson under test:
# Example values only - substitute your bench's IPs and interface names.
# Substitute your actual iperf3 server IP (e.g. 192.0.2.50)
# and each local interface IP (e.g. 192.0.2.100 for PCIe wlan0, 192.0.2.102 for USB wlan1)

# Benchmark the PCIe interface (wlan0 — if your carrier board already has an onboard M.2 card claiming wlan0, substitute your PCIe adapter's interface, e.g. wlp1s0):
iperf3 -c 192.0.2.50 -B 192.0.2.100 --bind-dev wlan0 -t 10

# Benchmark the USB WiFi 7 interface:
iperf3 -c 192.0.2.50 -B 192.0.2.102 --bind-dev wlan1 -t 10

# Confirm the binding landed on the intended interface, not merely the right source address:
ip -s link show wlan0

Empirical bench results

Testing between two nodes over a local wireless access point yielded the following measurements:

Both interfaces deliver equivalent throughput (~185 to 212 Mbit/s) because of the two-hop hairpin penalty: in a client-to-client test through one AP, every frame is transmitted twice over the same half-duplex channel (A → AP → B), halving usable airtime before TCP overhead is counted. The negotiated PHY rate describes one crossing by one radio — not the end-to-end achievable rate.

Why a 1733 Mbit/s PHY still tops out near 250 Mbit/s end-to-end: (1) the hairpin divides airtime by two, and (2) the client-side PHY rate assumes ideal modulation at that instant, while the actual throughput also carries retransmissions and contention overhead. To exercise the adapter’s own headroom, place the iperf3 peer on a wired host — that test exercises a single crossing per side and unlocks the 500-700+ Mbit/s single-hop class.

To bench the SuperSpeed-anchored state with the AP at 160 MHz, re-run the two-hop pair after moving the dongle to a Bus 002 port:

The SuperSpeed row is the verified comparison: re-anchoring to Bus 002 lifts TX throughput ~2.8× over the USB-2.0 TX baseline; the remaining ceiling is two-hop shared airtime, not the bus.

Step 8: Module persistence options

Following manual verification, choose a persistence strategy:

1. DKMS registration: From the cloned rtw89 directory, run sudo dkms install "$PWD" — the command the driver README documents. If DKMS stops at the module signing step (see the signing section above), fall back to the manual make install path already completed in Step 4.
2. Manual module maintenance: Retain the module in /lib/modules/6.8.12-1021-tegra/extra/rtw89/. If you hold kernel packages with sudo apt-mark hold nvidia-l4t-* linux-image-* linux-headers-*, the kernel ABI remains stable across reboots without recompilation.

Troubleshooting reference

Next steps & technical references

View Deep-Dive Toolkit Reference Guide →

• morrownr/rtw89 Driver Repository: Linux driver source for Realtek 802.11ax and 802.11be wireless adapters.
• JetPack 7.2 AX210/AX200 WiFi Setup Guide (Seeed Studio Wiki): Documents the platform-wide firmware .zst decompression requirement and provides prebuilt M.2 kernel modules.
• NVIDIA Jetson Linux Developer Guide (r39.2.1): Authoritative documentation for the JetPack 7.2.x kernel and firmware environment.