[Bug]: Asus K3 GEN 2

[fenixadam]

Affected Component

asusd (System Daemon / D-Bus)

Issue Description

Hi, i found a problem on your program. When you unplug the keyboard ASUS K3 GEN 2 the linux kernel starts to going crazy spamming when you plug it again:
set 10 00:05:26 tuf-f15 kernel: usb 3-1.2: reset full-speed USB device number 9 using xhci_hcd

The usb starts to reset in loop and you are basically missing keystrokes. The fix is to restart asusd service but it's a fragile fix. Is it fixable?

Steps to Reproduce

1. Unplug the ASUS K3 GEN 2
2. Plug it again
3. Missing keystrokes
4. usb 3-1.2: reset full-speed USB device number 9 using xhci_hcd

Expected vs Actual Behavior

I expected the keyboard to work perfectly but there was this problem.

Laptop Model / Board Name

FX507VU

Linux Distribution

CachyOS

Kernel Version

7.2.3-1-cachyos

asusctl / asusd / ROG Control Center Version

asusctl v6.4.0 Software version: 6.4.0 Product family: ASUS TUF Gaming F15 Board name: FX507VU Supported Core Functions: [ "xyz.ljones.AsusArmoury", "xyz.ljones.Aura", "xyz.ljones.FanCurves", "xyz.ljones.Platform", ] Supported Platform Properties: [ ChargeControlEndThreshold, ThrottlePolicy, ] Supported Keyboard Brightness: [ Off, Low, Med, High, ] Supported Aura Modes: [ Static, Breathe, RainbowCycle, Pulse, ] Supported Aura Zones: [] Supported Aura Power Zones: [ Keyboard, ]

Desktop Environment & Display Server

KDE Plasma (Wayland)

Relevant Logs

[Ghoul4500]

I feel like this is related to the hidraw bug that was fixed in ogc kernel. Using the OGC kernel, the Nobara kernel, or the G14 kernel should fix this issue. Can you please check this and let me know?

https://discuss.cachyos.org/t/keyboard-input-issues-on-asus-rog-strix-16-2025-with-cachyos-during-gaming/30823/8

[fenixadam]

I made a fix by myself with the help of Claude. It was not a kernel problem. I hope the creator of this repo fix it soon.

// Plan:
// - Manager has udev monitor on USB looking for ROG devices
// - If a device is found, add it to watch
// - Add it to Zbus server
// - If udev sees device removed then remove the zbus path

use std::collections::{HashMap, HashSet};
use std::sync::Arc;

use dmi_id::DMIID;
use log::{debug, error, info, warn};
use mio::{Events, Interest, Poll, Token};
use rog_platform::error::PlatformError;
use rog_platform::hid_raw::HidRaw;
use tokio::sync::Mutex;
use udev::{Device, MonitorBuilder};
use zbus::Connection;
use zbus::zvariant::{ObjectPath, OwnedObjectPath};

use crate::ASUS_ZBUS_PATH;
use crate::aura_anime::trait_impls::AniMeZbus;
use crate::aura_laptop::trait_impls::AuraZbus;
use crate::aura_scsi::trait_impls::ScsiZbus;
use crate::aura_slash::trait_impls::SlashZbus;
use crate::aura_types::DeviceHandle;
use crate::error::RogError;

const MOD_NAME: &str = "aura";

/// Returns only the Device details concatenated in a form usable for
/// adding/appending to a filename
pub fn filename_partial(parent: &Device) -> Option {
if let Some(id_product) = parent.attribute_value("idProduct") {
let id_product = id_product.to_string_lossy();
let mut path = if let Some(devnum) = parent.attribute_value("devnum") {
let devnum = devnum.to_string_lossy();
if let Some(devpath) = parent.attribute_value("devpath") {
let devpath = devpath.to_string_lossy();
format!("{id_product}{devnum}{devpath}")
} else {
format!("{id_product}_{devnum}")
}
} else {
format!("{id_product}")
};
if path.contains('.') {
warn!("dbus path for {id_product} contains ., removing");
path.replace('.', "").clone_into(&mut path);
}
return Some(ObjectPath::from_str_unchecked(&path).into());
}
None
}

fn dbus_path_for_dev(parent: &Device) -> Option {
if let Some(filename) = filename_partial(parent) {
return Some(
ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{filename}"))
.into(),
);
}
None
}

fn dbus_path_for_tuf() -> OwnedObjectPath {
ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/tuf")).into()
}

fn dbus_path_for_slash() -> OwnedObjectPath {
ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/slash")).into()
}

fn dbus_path_for_anime() -> OwnedObjectPath {
ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/anime")).into()
}

fn dbus_path_for_scsi(prod_id: &str) -> OwnedObjectPath {
ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{prod_id}_scsi")).into()
}

fn dev_prop_matches(dev: &Device, prop: &str, value: &str) -> bool {
if let Some(p) = dev.property_value(prop) {
return p == value;
}
false
}

/// A device.
///
/// Each controller within should track its dbus path so it can be removed if
/// required.
pub struct AsusDevice {
device: DeviceHandle,
dbus_path: OwnedObjectPath,
hid_key: Option,
}

pub struct DeviceManager {
_dbus_connection: Connection,
_hid_handles: Arc<Mutex<HashMap<String, Arc<Mutex>>>>,
_seen_usb_interfaces: Arc<Mutex<HashMap<String, HashSet>>>,
}

/// Returns true if this hidraw device is a non-Aura interface on the
/// ASUS Zephyrus Duo (0b05:1ce6) composite device and should be skipped.
///
/// 0b05:1ce6 exposes multiple HID interfaces; only interface 1.2 is the
/// real Aura/vendor control interface (report ID 0x5d, Output/Feature
/// capable). Other interfaces reuse that report ID for unrelated
/// Input-only data. Used by both startup enumeration and hotplug
/// add-event handling so the wrong interface can never be selected,
/// including after USB reset/resume.
fn is_non_aura_1ce6_interface(device: &Device) -> bool {
if let Ok(Some(usb_parent)) = device.parent_with_subsystem_devtype("usb", "usb_device") {
let vendor = usb_parent.attribute_value("idVendor");
let product = usb_parent.attribute_value("idProduct");

    if vendor == Some(std::ffi::OsStr::new("0b05"))
        && product == Some(std::ffi::OsStr::new("1ce6"))
    {
        let syspath = device.syspath().to_string_lossy().to_string();
        if !syspath.contains(":1.2/") {
            debug!("Skipping non-Aura 1ce6 HID interface: {}", syspath);
            return true;
        }
        debug!(
            "Selected ASUS 0b05:1ce6 Aura HID interface 1.2: {}",
            syspath
        );
    }
}
false

}

impl DeviceManager {
#[allow(clippy::type_complexity)]
async fn get_or_create_hid_handle(
handles: &Arc<Mutex<HashMap<String, Arc<Mutex>>>>,
endpoint: &Device,
) -> Result<(Arc<Mutex>, String), RogError> {
let dev_node = endpoint
.devnode()
.ok_or_else(|| RogError::MissingFunction("hidraw devnode missing".to_string()))?;
let key = dev_node.to_string_lossy().to_string();

    if let Some(existing) = handles.lock().await.get(&key).cloned() {
        return Ok((existing, key));
    }

    let hidraw = HidRaw::from_device(endpoint.clone())?;
    let handle = Arc::new(Mutex::new(hidraw));
    handles.lock().await.insert(key.clone(), handle.clone());
    Ok((handle, key))
}

async fn init_hid_devices(
    connection: &Connection,
    device: Device,
    handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
) -> Result<Vec<AsusDevice>, RogError> {
    let mut devices = Vec::new();
    if let Some(usb_device) = device.parent_with_subsystem_devtype("usb", "usb_device")?
        && let Some(usb_id) = usb_device.attribute_value("idProduct")
        && let Some(vendor_id) = usb_device.attribute_value("idVendor")
    {
        if vendor_id != "0b05" {
            debug!("Not ASUS vendor ID: {}", vendor_id.to_string_lossy());
            return Ok(devices);
        }
        // Almost all devices are identified by the productId.
        // So let's see what we have and:
        // 1. Generate an interface path
        // 2. Create the device
        // Use the top-level endpoint, not the parent
        if let Ok((dev, hid_key)) = Self::get_or_create_hid_handle(&handles, &device).await {
            debug!("Testing device {usb_id:?}");
            // SLASH DEVICE
            if let Ok(dev_type) =
                DeviceHandle::new_slash_hid(dev.clone(), usb_id.to_str().unwrap_or_default())
                    .await
                && let DeviceHandle::Slash(slash) = dev_type.clone()
            {
                let path = dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_slash());
                let ctrl = SlashZbus::new(slash);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| {
                        error!("Failed to start Slash tasks: {e:?}, not adding this device")
                    })
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: Some(hid_key.clone()),
                    });
                }
            }
            // ANIME MATRIX DEVICE
            if let Ok(dev_type) =
                DeviceHandle::maybe_anime_hid(dev.clone(), usb_id.to_str().unwrap_or_default())
                    .await
                && let DeviceHandle::AniMe(anime) = dev_type.clone()
            {
                let path = dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_anime());
                let ctrl = AniMeZbus::new(anime);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| {
                        error!("Failed to start AniMe tasks: {e:?}, not adding this device")
                    })
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: Some(hid_key.clone()),
                    });
                }
            }
            // AURA LAPTOP DEVICE
            if let Ok(dev_type) =
                DeviceHandle::maybe_laptop_aura(Some(dev), usb_id.to_str().unwrap_or_default())
                    .await
                && let DeviceHandle::Aura(aura) = dev_type.clone()
            {
                let path = dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_tuf());
                let ctrl = AuraZbus::new(aura);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| {
                        error!("Failed to start Aura tasks: {e:?}, not adding this device")
                    })
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: Some(hid_key),
                    });
                }
            }
        } else {
            warn!("Failed to initialise shared hid handle for {usb_id:?}");
        }
    }
    Ok(devices)
}

/// To be called on daemon startup
async fn init_all_hid(
    connection: &Connection,
    handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
) -> Result<Vec<AsusDevice>, RogError> {
    // Ensure we only process one hidraw interface per physical USB device.
    // A USB device can expose multiple HID interfaces (and thus multiple hidraw nodes).
    // Processing more than one causes duplicate device initialisation which can
    // interfere with the kernel's own HID driver and trigger a USB reset loop.
    let mut seen_usb_parents: HashSet<String> = HashSet::new();
    let mut devices: Vec<AsusDevice> = Vec::new();

    let mut enumerator = udev::Enumerator::new().map_err(|err| {
        warn!("{}", err);
        PlatformError::Udev("enumerator failed".into(), err)
    })?;

    enumerator.match_subsystem("hidraw").map_err(|err| {
        warn!("{}", err);
        PlatformError::Udev("match_subsystem failed".into(), err)
    })?;

    for device in enumerator
        .scan_devices()
        .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
    {
        // ASUS Zephyrus Duo keyboard 0b05:1ce6 is a composite HID device;
        // see is_non_aura_1ce6_interface for why interface 1.2 is required.
        if is_non_aura_1ce6_interface(&device) {
            continue;
        }

        if let Ok(Some(usb_parent)) = device.parent_with_subsystem_devtype("usb", "usb_device")
        {
            let parent_path = usb_parent.syspath().to_string_lossy().to_string();
            if !seen_usb_parents.insert(parent_path) {
                debug!("Skipping duplicate ASUS hidraw for USB parent already processed");
                continue;
            }
        }

        devices.append(&mut Self::init_hid_devices(connection, device, handles.clone()).await?);
    }

    Ok(devices)
}

/// Resolve the `/dev/sgN` (scsi_generic) node backing a block device.
///
/// Walks up from the block device to its owning scsi_device and reads the
/// `scsi_generic/sgN` child. Works for whole-disk (`/dev/sda`) and
/// partition (`/dev/sda1`) nodes alike, since the scsi_device is a common
/// ancestor. Returns None if no sg node exists (e.g. the `sg` module is
/// not loaded).
fn sg_node_for_block(device: &Device) -> Option<String> {
    let mut current = device.parent();
    while let Some(d) = current {
        if let Ok(entries) = std::fs::read_dir(d.syspath().join("scsi_generic")) {
            for entry in entries.flatten() {
                if let Some(name) = entry.file_name().to_str() {
                    let node = format!("/dev/{name}");
                    if std::path::Path::new(&node).exists() {
                        return Some(node);
                    }
                }
            }
        }
        current = d.parent();
    }
    None
}

async fn init_scsi(
    connection: &Connection,
    device: &Device,
    path: OwnedObjectPath,
) -> Option<AsusDevice> {
    // "ID_MODEL_ID" "1932"
    // "ID_VENDOR_ID" "0b05"
    if dev_prop_matches(device, "ID_VENDOR_ID", "0b05")
        && let Some(dev_node) = device.devnode()
    {
        let prod_id = device
            .property_value("ID_MODEL_ID")
            .unwrap_or_default()
            .to_string_lossy();
        // SG_IO with vendor commands on the block node (/dev/sdX)
        // requires CAP_SYS_RAWIO, which the hardened asusd unit drops
        // (every ioctl EPERMs and is silently swallowed by write_effect).
        // The scsi_generic /dev/sgN node gates access at open() via
        // file permissions instead, so it works with no capabilities,
        // the same path sg3_utils / OpenRGB use.
        //
        // On hotplug the sg node can appear just after the block node,
        // so retry briefly before falling back to the block device
        // (which would EPERM). At startup the node already exists, so
        // the first attempt succeeds with no delay.
        let mut sg_node = None;
        for attempt in 0..8u8 {
            if let Some(sg) = Self::sg_node_for_block(device) {
                sg_node = Some(sg);
                break;
            }
            if attempt < 7 {
                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
            }
        }
        let dev_str = match sg_node {
            Some(sg) => Some(sg),
            None => {
                warn!(
                    "No /dev/sgN for SCSI device after retries; falling back to block \
                         node {:?} (SG_IO will EPERM unless asusd has CAP_SYS_RAWIO)",
                    dev_node
                );
                dev_node.as_os_str().to_str().map(|s| s.to_string())
            }
        };
        if let Some(dev_str) = dev_str
            && let Ok(dev_type) = DeviceHandle::maybe_scsi(&dev_str, &prod_id).await
            && let DeviceHandle::Scsi(scsi) = dev_type.clone()
        {
            let ctrl = ScsiZbus::new(scsi);
            if ctrl
                .start_tasks(connection, path.clone())
                .await
                .map_err(|e| {
                    error!("Failed to start SCSI tasks: {e:?}, not adding this device")
                })
                .is_ok()
            {
                return Some(AsusDevice {
                    device: dev_type,
                    dbus_path: path,
                    hid_key: None,
                });
            }
        }
    }
    None
}

async fn init_all_scsi(connection: &Connection) -> Result<Vec<AsusDevice>, RogError> {
    // track and ensure we use only one hidraw per prod_id
    // let mut interfaces = HashSet::new();
    let mut devices: Vec<AsusDevice> = Vec::new();

    let mut enumerator = udev::Enumerator::new().map_err(|err| {
        warn!("{}", err);
        PlatformError::Udev("enumerator failed".into(), err)
    })?;

    enumerator.match_subsystem("block").map_err(|err| {
        warn!("{}", err);
        PlatformError::Udev("match_subsystem failed".into(), err)
    })?;

    let mut found = Vec::new();
    for device in enumerator
        .scan_devices()
        .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
    {
        if let Some(serial) = device.property_value("ID_SERIAL_SHORT") {
            let serial = serial.to_string_lossy().to_string();
            let path = dbus_path_for_scsi(&serial);
            if found.contains(&path) {
                continue;
            }

            if let Some(dev) = Self::init_scsi(connection, &device, path.clone()).await {
                devices.push(dev);
                found.push(path);
            }
        } else {
            debug!("No serial for SCSI device: {:?}", device.devpath());
        }
    }

    Ok(devices)
}

pub async fn find_all_devices(
    connection: &Connection,
    handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
) -> Vec<AsusDevice> {
    let mut devices: Vec<AsusDevice> = Vec::new();
    // HID first, always
    if let Ok(devs) = &mut Self::init_all_hid(connection, handles.clone()).await {
        devices.append(devs);
    }
    // USB after, need to check if HID picked something up and if so, skip it
    let mut do_anime = true;
    let mut do_slash = true;
    let mut do_kb_backlight = true;
    for dev in devices.iter() {
        if matches!(dev.device, DeviceHandle::Slash(_)) {
            do_slash = false;
        }
        if matches!(dev.device, DeviceHandle::AniMe(_)) {
            do_anime = false;
        }
        if matches!(dev.device, DeviceHandle::Aura(_) | DeviceHandle::OldAura(_)) {
            do_kb_backlight = false;
        }
    }

    if do_slash {
        if let Ok(dev_type) = DeviceHandle::new_slash_usb().await {
            if let DeviceHandle::Slash(slash) = dev_type.clone() {
                let path = dbus_path_for_slash();
                let ctrl = SlashZbus::new(slash);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| {
                        error!("Failed to start Slash tasks: {e:?}, not adding this device")
                    })
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: None,
                    });
                }
            }
        } else {
            info!("Tested device was not Slash");
        }
    }

    if do_anime {
        if let Ok(dev_type) = DeviceHandle::maybe_anime_usb().await {
            // TODO: this is copy/pasted
            if let DeviceHandle::AniMe(anime) = dev_type.clone() {
                let path = dbus_path_for_anime();
                let ctrl = AniMeZbus::new(anime);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| error!("Failed to start tasks: {e:?}, not adding this device"))
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: None,
                    });
                }
            }
        } else {
            info!("Tested device was not AniMe Matrix");
        }
    }

    if do_kb_backlight {
        // TUF AURA LAPTOP DEVICE
        // product_name = ASUS TUF Gaming F15 FX507ZE_FX507ZE
        // product_family = ASUS TUF Gaming F15
        let product_name = DMIID::new().unwrap_or_default().product_name;
        let product_family = DMIID::new().unwrap_or_default().product_family;
        info!(
            "No USB keyboard aura, system is {product_name}, try using sysfs backlight control"
        );
        if product_name.contains("TUF") || product_family.contains("TUF") {
            info!("TUF laptop, try using sysfs backlight control");
            if let Ok(dev_type) = DeviceHandle::maybe_laptop_aura(None, "tuf").await
                && let DeviceHandle::Aura(aura) = dev_type.clone()
            {
                let path = dbus_path_for_tuf();
                let ctrl = AuraZbus::new(aura);
                if ctrl
                    .start_tasks(connection, path.clone())
                    .await
                    .map_err(|e| {
                        error!("Failed to start TUF Aura tasks: {e:?}, not adding this device")
                    })
                    .is_ok()
                {
                    devices.push(AsusDevice {
                        device: dev_type,
                        dbus_path: path,
                        hid_key: None,
                    });
                }
            }
        }
    }

    if let Ok(devs) = &mut Self::init_all_scsi(connection).await {
        devices.append(devs);
    }

    devices
}

pub async fn new(connection: Connection) -> Result<Self, RogError> {
    let conn_copy = connection.clone();
    let hid_handles = Arc::new(Mutex::new(HashMap::new()));
    let devices = Self::find_all_devices(&conn_copy, hid_handles.clone()).await;
    info!("Found {} valid devices on startup", devices.len());
    let devices = Arc::new(Mutex::new(devices));
    // Tracks, per physical USB parent (keyed by its syspath), the set of
    // hidraw devnodes currently seen for it. This mirrors the
    // `seen_usb_parents` dedup that `init_all_hid` applies at startup
    // (only one hidraw interface per physical USB device is processed),
    // but persisted across hotplug events: without it, a composite
    // device (e.g. a keyboard exposing several HID interfaces) that is
    // never recognised as a valid Aura/Slash/AniMe device gets every one
    // of its interfaces opened in write mode on every hotplug `add`,
    // instead of just the first one as happens at startup. The entry
    // for a USB parent is removed once all of its hidraw interfaces
    // have been removed, so a genuine physical reconnect is treated as
    // fresh again.
    let seen_usb_interfaces: Arc<Mutex<HashMap<String, HashSet<String>>>> =
        Arc::new(Mutex::new(HashMap::new()));
    let manager = Self {
        _dbus_connection: connection,
        _hid_handles: hid_handles.clone(),
        _seen_usb_interfaces: seen_usb_interfaces.clone(),
    };

    // TODO: The /sysfs/ LEDs don't cause events, so they need to be manually
    // checked for and added

    let hid_handles_thread = hid_handles.clone();
    let seen_usb_interfaces_thread = seen_usb_interfaces.clone();
    std::thread::spawn(move || {
        let mut monitor = MonitorBuilder::new()?.listen()?;
        let mut poll = Poll::new()?;
        let mut events = Events::with_capacity(1024);
        poll.registry()
            .register(&mut monitor, Token(0), Interest::READABLE)?;

        let rt = tokio::runtime::Runtime::new().expect("Unable to create Runtime");
        let _enter = rt.enter();
        loop {
            if poll.poll(&mut events, None).is_err() {
                continue;
            }
            for event in monitor.iter() {
                let action = event
                    .action()
                    .unwrap_or_default()
                    .to_string_lossy()
                    .to_string();

                let subsys = if let Some(subsys) = event.subsystem() {
                    subsys.to_string_lossy().to_string()
                } else {
                    continue;
                };

                let devices = devices.clone();
                let conn_copy = conn_copy.clone();
                let hid_handles = hid_handles_thread.clone();
                let seen_usb_interfaces = seen_usb_interfaces_thread.clone();
                rt.block_on(async move {
                    // SCSCI devs
                    if subsys == "block" {
                        if action == "remove" {
                            if let Some(serial) =
                                event.device().property_value("ID_SERIAL_SHORT")
                            {
                                let serial = serial.to_string_lossy().to_string();
                                let path = dbus_path_for_scsi(&serial);

                                let index = if let Some(index) = devices
                                    .lock()
                                    .await
                                    .iter()
                                    .position(|dev| dev.dbus_path == path)
                                {
                                    index
                                } else {
                                    if dev_prop_matches(&event.device(), "ID_VENDOR_ID", "0b05")
                                    {
                                        warn!("No device for dbus path: {path:?}");
                                    }
                                    return Ok(());
                                };
                                info!("removing: {path:?}");
                                let dev = devices.lock().await.remove(index);
                                let path = path.clone();
                                if let DeviceHandle::Scsi(_) = dev.device {
                                    conn_copy
                                        .object_server()
                                        .remove::<ScsiZbus, _>(&path)
                                        .await?;
                                }
                            }
                        } else if action == "add" {
                            let evdev = event.device();
                            if let Some(serial) = evdev.property_value("ID_SERIAL_SHORT") {
                                let serial = serial.to_string_lossy().to_string();
                                let path = dbus_path_for_scsi(&serial);
                                if let Some(new_devs) =
                                    Self::init_scsi(&conn_copy, &evdev, path).await
                                {
                                    devices.lock().await.append(&mut vec![new_devs]);
                                }
                            }
                        };
                    }

                    if subsys == "hidraw" {
                        if action == "remove" {
                            // Key cleanup off the removed hidraw node itself, NOT the
                            // USB parent. By the time a `remove` uevent arrives the USB
                            // parent is usually already detached from sysfs, so
                            // `parent_with_subsystem_devtype` returns None; gating the
                            // cleanup on it meant we kept the `Arc<Mutex<HidRaw>>` (held
                            // by both the handle map and the live zbus object) alive, so
                            // the open hidraw `File` was never dropped. The kernel only
                            // frees a hidraw minor once no fd remains open on it, so every
                            // re-enumeration (s2idle resume, dock/undock) leaked one
                            // minor until the 64-entry pool was exhausted system-wide.
                            // The uevent always carries DEVNAME, so the devnode is the
                            // stable key (and is exactly what we store as `hid_key`).
                            let removed_node = event
                                .device()
                                .devnode()
                                .map(|n| n.to_string_lossy().to_string());
                            if let Some(removed_node) = removed_node {
                                // Tear down any zbus objects backed by this node.
                                let removals: Vec<usize> = devices
                                    .lock()
                                    .await
                                    .iter()
                                    .enumerate()
                                    .filter_map(|(i, dev)| {
                                        if dev.hid_key.as_deref() == Some(removed_node.as_str())
                                        {
                                            Some(i)
                                        } else {
                                            None
                                        }
                                    })
                                    .collect();
                                // Iter in reverse so as to not screw up indexing
                                for index in removals.iter().rev() {
                                    let dev = devices.lock().await.remove(*index);
                                    let path = dev.dbus_path.clone();
                                    let res = match dev.device {
                                        DeviceHandle::Aura(_) => {
                                            conn_copy
                                                .object_server()
                                                .remove::<AuraZbus, _>(&path)
                                                .await?
                                        }
                                        DeviceHandle::Slash(_) => {
                                            conn_copy
                                                .object_server()
                                                .remove::<SlashZbus, _>(&path)
                                                .await?
                                        }
                                        DeviceHandle::AniMe(_) => {
                                            conn_copy
                                                .object_server()
                                                .remove::<AniMeZbus, _>(&path)
                                                .await?
                                        }
                                        DeviceHandle::Scsi(_) => {
                                            conn_copy
                                                .object_server()
                                                .remove::<ScsiZbus, _>(&path)
                                                .await?
                                        }
                                        // sysfs/USB-backed handles (e.g. OldAura) own no
                                        // shared hidraw fd; nothing to remove here.
                                        _ => false,
                                    };
                                    info!("AuraManager removed: {path:?}, {res}");
                                }
                                // Always drop the shared handle for this node, even if no
                                // AsusDevice referenced it, so the fd (and minor) is freed.
                                if hid_handles.lock().await.remove(&removed_node).is_some() {
                                    info!("Dropped hid handle for {removed_node}");
                                }
                                // Remove this devnode from whichever USB-parent's interface
                                // set it belongs to. Once a parent's set is empty (all of
                                // its hidraw interfaces have been removed, i.e. the physical
                                // device is genuinely gone) drop the parent entry too, so a
                                // future reconnect is treated as fresh again.
                                let mut seen = seen_usb_interfaces.lock().await;
                                let mut now_empty = None;
                                for (parent, nodes) in seen.iter_mut() {
                                    if nodes.remove(&removed_node) && nodes.is_empty() {
                                        now_empty = Some(parent.clone());
                                        break;
                                    }
                                }
                                if let Some(parent) = now_empty {
                                    seen.remove(&parent);
                                }
                            }
                        } else if action == "add"
                            && let Some(parent) =
                                event.parent_with_subsystem_devtype("usb", "usb_device")?
                        {
                            // Guard against initialising a second hidraw interface for a
                            // USB device we already track. Without this, a USB reset
                            // (e.g. triggered by an earlier duplicate init) fires
                            // remove+add events that cause another duplicate init and a
                            // permanent reset loop.
                            if let Some(path) = dbus_path_for_dev(&parent)
                                && devices.lock().await.iter().any(|d| d.dbus_path == path)
                            {
                                debug!(
                                    "Hotplug add: device {path:?} already registered, skipping"
                                );
                                return Ok(());
                            }

                            // Mirror the startup `seen_usb_parents` dedup: only ever
                            // process the FIRST hidraw interface seen for a given
                            // physical USB device. Without this, a composite device
                            // (e.g. a keyboard exposing several HID interfaces) that
                            // never ends up registered as a recognised Aura/Slash/AniMe
                            // device - because its product ID is unknown - gets every
                            // one of its interfaces opened in write mode on every
                            // hotplug `add`, whereas startup enumeration only ever
                            // touches one. Opening multiple interfaces concurrently on
                            // such a device has been observed to destabilise its
                            // firmware and trigger a USB reset loop with dropped
                            // keystrokes. The parent's entry is cleared once all of its
                            // interfaces are removed (see the `hidraw` "remove" branch
                            // above), so a genuine physical reconnect is still treated
                            // as fresh.
                            let parent_syspath = parent.syspath().to_string_lossy().to_string();
                            let evdev = event.device();
                            let this_node = evdev
                                .devnode()
                                .map(|n| n.to_string_lossy().to_string());
                            if let Some(this_node) = this_node.clone() {
                                let mut seen = seen_usb_interfaces.lock().await;
                                let nodes = seen.entry(parent_syspath).or_default();
                                let is_first_interface = nodes.is_empty();
                                nodes.insert(this_node.clone());
                                if !is_first_interface {
                                    debug!(
                                        "Hotplug add: {this_node} is an additional \
                                         interface on an already-seen USB device, skipping"
                                    );
                                    return Ok(());
                                }
                            }

                            if is_non_aura_1ce6_interface(&evdev) {
                                return Ok(());
                            }
                            if let Ok(mut new_devs) =
                                Self::init_hid_devices(&conn_copy, evdev, hid_handles.clone())
                                    .await
                                    .map_err(|e| error!("Couldn't add new device: {e:?}"))
                            {
                                devices.lock().await.append(&mut new_devs);
                            }
                        }
                    }
                    Ok::<(), RogError>(())
                })
                .map_err(|e| error!("{e:?}"))
                .ok();
            }
        }
        // Required for return type on spawn
        #[allow(unreachable_code)]
        Ok::<(), RogError>(())
    });
    Ok(manager)
}

}

[Ghoul4500]

I'll need more information about the bug for a proper diagnosis. What do you mean by "kernel starts spamming" for example. Have you tested the OGC kernel to be sure it's not related to the same bug?

As for the content you pasted, I think it would be good if you can commit that to your own fork of this repo and then I can see the actual diff rather than the entire file pasted in a comment

[fenixadam]

I didn't test the OGC kernel but i already had this problem with this app. I knew that was something about the code. In fact the asusctl detected the ASUS K3 GEN 2 as a builtin laptop keyboard possible and failed to initialize or something. So i don't know why it started to reset the usb speed. This fix fixed completely the problem for now. Im testing

I made a fork with the changes made. The change is in /asusd/aura_manager.rs

However i wanted to ask also why intel igpu temps are not visible anymore? On rog-control-center are N/D but i mean that was the normal behaviour because also on windows you wouldn't be able to see the igpu UHD temps.

[Ghoul4500]

I didn't test the OGC kernel but i already had this problem with this app

If it is anything like the same issue, you will get keydrops if anything polls the hidraw interface (proton also does this) so I still think it's worth verifying that keydrops happen even with the kernel fix applied.

I will have a look at your fork when I get the time

intel igpu temps are not visible anymore

Probably a different bug. I'm able to see this as well. I'll check this out, thanks for pointing it out