Fix: IWD Not Detecting Hotplug WiFi Adapters On Linux

Aug 5, 2025 by ADMIN 54 views

Troubleshooting Wi-Fi Hotplug Detection with IWD on Linux

Hey guys! Ever run into that super frustrating issue where your Wi-Fi adapter just won't show up after you plug it in? Yeah, it's a pain. Especially when you've gone through the trouble of setting up iwd, the Intel Wireless Daemon, to manage your wireless connections. Today, we’re diving deep into troubleshooting why iwd might not be detecting your hotplugged Wi-Fi devices, specifically focusing on a Void Linux setup, but the principles apply to pretty much any Linux distro. Let's get started!

Understanding the Hotplugging Problem with IWD

So, you've made the switch. You've ditched the old guard—wpa_supplicant and NetworkManager—and embraced iwd, hoping for a sleeker, more streamlined wireless experience. Everything's smooth sailing until you plug in that trusty USB Wi-Fi adapter, and… nothing. Crickets. Your system acts like you didn't even bother plugging anything in. This is a common hiccup, and thankfully, it's usually fixable.

The core of the issue lies in how your system detects and manages hardware changes. When you hotplug a device (like a Wi-Fi adapter), your system needs to recognize the new hardware, load the necessary drivers, and make the device available to applications like iwd. If any of these steps falter, you're left scratching your head, wondering why your Wi-Fi isn't working.

Here’s a breakdown of the common culprits:

Driver Issues: The most frequent offender. If the correct driver isn't loaded or is malfunctioning, your system simply won't recognize the Wi-Fi adapter. This can happen if the driver isn't installed, is outdated, or is incompatible with your kernel.
udev Rules: udev is the Linux subsystem that manages device events. It uses rules to determine what actions to take when a device is plugged in. If your udev rules aren't correctly configured, your Wi-Fi adapter might not be properly initialized.
IWD Configuration: While iwd is generally pretty good at detecting devices, sometimes it might need a little nudge. Misconfiguration or missing settings can prevent iwd from seeing your hotplugged adapter.
Kernel Issues: In rare cases, the kernel itself might have issues recognizing the device. This is less common but can occur with very new or very old hardware.

To effectively troubleshoot this, we need to systematically investigate each of these areas. We’ll start with the basics and then move on to more advanced techniques. By the end of this guide, you’ll have a solid understanding of how to diagnose and fix Wi-Fi hotplugging issues with iwd.

Step 1: Verifying Device Detection

Okay, first things first, let's make sure your system is even seeing the Wi-Fi adapter in the first place. We're going to use a few command-line tools to peek under the hood. Don't worry; it's not as scary as it sounds. Open up your terminal—it's your best friend in these situations.

Using `lsusb`

lsusb is your go-to command for listing USB devices. Plug in your Wi-Fi adapter and run:

sudo lsusb

This will spit out a list of all USB devices connected to your system. Scan through the output and look for your Wi-Fi adapter. It should have a recognizable name, often including the manufacturer (like Realtek, MediaTek, or Atheros). If you see your device listed here, that's a good sign—your system is at least recognizing the hardware.

If you don't see your adapter listed, there might be a more fundamental problem, such as a faulty USB port or a hardware issue with the adapter itself. Try plugging the adapter into a different USB port to rule out a port issue. If it's still not showing up, the adapter might be the culprit.

Using `iwconfig`

Next up, let's see if iwconfig can detect your wireless interface. iwconfig is a tool specifically for configuring wireless network interfaces. Run:

sudo iwconfig

This command lists all wireless interfaces on your system. If your Wi-Fi adapter is properly detected and initialized, you should see an entry for it, typically named something like wlan0 or wlp2s0. If you see this, it means the system recognizes the adapter as a wireless device, which is another step in the right direction.

If you don't see your adapter listed in iwconfig, it could indicate a driver issue or a problem with udev rules. We'll dig into these possibilities in the next steps.

Checking Kernel Messages with `dmesg`

For a more detailed look at what's happening behind the scenes, we can use dmesg. This command displays the kernel's message buffer, which includes information about hardware detection and driver loading. After plugging in your Wi-Fi adapter, run:

dmesg | tail -n 50

The | tail -n 50 part just shows the last 50 lines of the output, making it easier to focus on recent events. Look for messages related to your Wi-Fi adapter. You might see messages about driver loading, device initialization, or even errors. These messages can provide valuable clues about what's going wrong.

For example, if you see an error message like "Driver X for device Y not found", you know you have a driver issue. Or, if you see messages about udev rules being applied, you can investigate those rules further.

By using these three commands—lsusb, iwconfig, and dmesg—you can get a pretty good sense of whether your system is detecting your Wi-Fi adapter and where the potential problems might lie. If you've made it this far and your adapter is showing up in lsusb but not iwconfig, you're likely dealing with a driver issue. Let's tackle that next.

Step 2: Diving into Driver Issues

So, you've confirmed that your system sees the Wi-Fi adapter plugged in, but it's not showing up as a wireless interface. This usually points to a driver problem. Drivers are the software that allows your operating system to communicate with your hardware. If the correct driver isn't installed, is outdated, or is incompatible, your Wi-Fi adapter won't work correctly.

The first thing we need to do is identify which driver your Wi-Fi adapter needs. This can sometimes be tricky, but we can use the information we gathered from lsusb to help us. Remember the output from lsusb? It includes the vendor and product IDs for your device. We can use these IDs to search for the correct driver.

Identifying the Correct Driver

Let's say the lsusb output for your Wi-Fi adapter looks something like this:

Bus 002 Device 003: ID 148f:7601 Ralink Technology, Corp. MT7601U Wireless Adapter

The important bits here are the vendor ID (148f) and the product ID (7601). With these, you can head over to a resource like the Linux Wireless website or simply use a search engine like Google. Search for "148f:7601 Linux driver" and you'll likely find information about the driver required for your adapter. In this case, the mt7601u driver is commonly used for Ralink MT7601U-based adapters.

Installing or Reinstalling Drivers

Once you've identified the driver, you need to make sure it's installed on your system. The process for installing drivers varies depending on your Linux distribution. On Debian-based systems (like Ubuntu), you might use apt. On Arch-based systems, you might use pacman. And on Void Linux, which we're focusing on here, you'll likely use xbps.

For example, if you've identified the mt7601u driver as the one you need, you might try installing it on Void Linux using:

sudo xbps-install -S mt7601u-firmware

This command installs the firmware package associated with the mt7601u driver. Firmware is essential for the driver to function correctly.

After installing the driver (or reinstalling it, if you suspect it's corrupted), you'll want to reload the kernel module. This tells the kernel to load the new or updated driver. You can do this using the modprobe command. First, unload the module (if it's loaded):

sudo modprobe -r mt7601u

Then, load it again:

sudo modprobe mt7601u

Replace mt7601u with the actual name of your driver module.

Checking for Firmware

Sometimes, the driver itself isn't enough. Many Wi-Fi adapters also require firmware—small pieces of software that run on the device itself. If the firmware isn't installed, the driver might load correctly, but the adapter still won't work.

Firmware packages are usually separate from driver packages. In the example above, we installed mt7601u-firmware. Make sure you've installed the appropriate firmware package for your adapter. If you're not sure, check the documentation for your adapter or search online for information about the required firmware.

Dealing with DKMS

Some drivers are provided as DKMS (Dynamic Kernel Module Support) packages. DKMS allows drivers to be automatically rebuilt when the kernel is updated. This is super handy because it means you don't have to manually reinstall your driver every time you update your kernel.

If you're using a DKMS driver, make sure DKMS is properly configured on your system. You might need to run a command like sudo dkms autoinstall to rebuild the driver against your current kernel.

By systematically identifying, installing, and reloading drivers, you can often resolve Wi-Fi hotplugging issues. If you've tried all of this and your adapter still isn't working, the problem might lie elsewhere. Let's move on to the next potential culprit: udev rules.

Step 3: Examining udev Rules

Okay, so you've made sure your drivers are in place, but your Wi-Fi adapter still isn't playing nice. Time to dive into udev rules. udev is the Linux subsystem that handles device events. When you plug in a device, udev kicks in, reads its rules, and determines what actions to take. If your udev rules aren't set up correctly, your Wi-Fi adapter might not be properly initialized.

udev rules are stored in files in the /etc/udev/rules.d/ directory. These files contain sets of rules that match device properties and trigger actions. Let's explore how to check these rules and make sure they're not the source of your woes.

Identifying Relevant udev Rules

The first step is to identify which udev rules might be affecting your Wi-Fi adapter. You could go through all the files in /etc/udev/rules.d/, but that's like searching for a needle in a haystack. A more efficient approach is to use the udevadm tool.

udevadm is a powerful command-line utility for managing udev. We can use it to inspect the properties of your Wi-Fi adapter and see which rules are being applied. Plug in your adapter and run:

udevadm monitor --environment

This command will monitor udev events in real-time. Plug in your Wi-Fi adapter, and you should see a stream of output related to the device being detected. Look for lines that start with UDEV [timestamp] add. These lines indicate that a new device has been added.

In the output, you'll see a bunch of environment variables associated with your device. These variables include information like the vendor ID, product ID, interface number, and more. These are the properties that udev rules match against.

For example, you might see something like:

UDEV [timestamp] add      /devices/pci0000:00/0000:00:14.0/usb2/2-2/2-2.2 (usb)
... 
    ID_VENDOR=Realtek
    ID_MODEL=802.11n_WLAN_Adapter
    ID_VENDOR_ID=0bda
    ID_MODEL_ID=8179
...

These variables are what you'll use to create or modify udev rules. Note the ID_VENDOR, ID_MODEL, ID_VENDOR_ID, and ID_MODEL_ID. These are crucial for identifying your device in a udev rule.

Checking Existing Rules

Now that you have the device properties, you can check if there are any existing udev rules that might be interfering with your adapter. Use the following command:

udevadm info --attribute-walk --path=$(udevadm info --query=path --name=wlan0)

Replace wlan0 with the actual name of your wireless interface (if it's detected). This command will walk through the device's attributes and show you which rules are being applied. Look for any rules that might be misconfigured or preventing your adapter from being properly initialized.

Creating Custom udev Rules

If you find that there are no rules for your device or that the existing rules are incorrect, you might need to create a custom udev rule. This can sound intimidating, but it's actually not too bad. A udev rule is just a text file with a set of conditions and actions.

Here's a basic example of a udev rule that sets the interface name for a Wi-Fi adapter:

ACTION==