Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1151d122 authored by Zhengping Jiang's avatar Zhengping Jiang
Browse files

Floss: add virtual uhid device if a wake-allowed device is bonded 

Create a uhid device in kernel to keep the adapter in monitored path for
wake events, if there is any wake-allowed bluetooth device bonded when
suspend starts.

Bug: 274548743
Bug: 278761132
Test: suspend resume with LE mouse bonded, wake up with mouse.

Change-Id: I8ce62b6de344e48f134d354a84295f04e956419d
parent 0d1f32af

system/gd/rust/linux/stack/src/suspend.rs

+23 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ use std::sync::{Arc, Mutex}; 
use tokio::sync::mpsc::Sender;



use bt_utils::socket::{BtSocket, HciChannels, MgmtCommand, HCI_DEV_NONE};

use bt_utils::uhid::UHid;



/// Defines the Suspend/Resume API.

///
@@ -152,6 +153,9 @@ pub struct Suspend { 
    connectable_to_restore: bool,

    /// Bluetooth adapter discoverable mode before suspending.

    discoverable_mode_to_restore: BtDiscMode,



    /// Virtual uhid device created during suspend.

    uhid: UHid,

}



impl Suspend {
@@ -175,6 +179,7 @@ impl Suspend { 
            suspend_state: Arc::new(Mutex::new(SuspendState::new())),

            connectable_to_restore: false,

            discoverable_mode_to_restore: BtDiscMode::NonDiscoverable,

            uhid: UHid::new(),

        }

    }
@@ -214,6 +219,11 @@ impl Suspend { 
        let bonded_connected = self.bt.lock().unwrap().get_bonded_and_connected_devices();

        self.media.lock().unwrap().filter_to_connected_audio_devices_from(&bonded_connected)

    }



    fn get_wake_allowed_device_bonded(&self) -> bool {

        let bt = self.bt.lock().unwrap();

        bt.get_bonded_devices().into_iter().any(|d| bt.get_remote_wake_allowed(d))

    }

}



impl ISuspend for Suspend {
@@ -260,6 +270,18 @@ impl ISuspend for Suspend { 
            self.audio_reconnect_joinhandle = None;

        }



        if self.get_wake_allowed_device_bonded() {

            let adapter_addr = self.bt.lock().unwrap().get_address().to_lowercase();

            match self.uhid.create(

                "suspend uhid".to_string(),

                adapter_addr,

                String::from(BD_ADDR_DEFAULT),

            ) {

                Err(e) => log::error!("Fail to create uhid {}", e),

                Ok(_) => (),

            }

        }



        self.intf.lock().unwrap().disconnect_all_acls();



        // Handle wakeful cases (Connected/Other)
@@ -298,6 +320,7 @@ impl ISuspend for Suspend { 
    fn resume(&mut self) -> bool {

        let hci_index = self.bt.lock().unwrap().get_hci_index();

        notify_suspend_state(hci_index, false);

        self.uhid.clear();



        self.intf.lock().unwrap().set_default_event_mask_except(0u64, 0u64);

system/gd/rust/linux/utils/Cargo.toml

+1 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ log = "0.4.14" 
nix = "0.23"

num-derive = "0.3"

num-traits = "0.2"

uhid-virt = "0.0.6"



[lib]

crate-type = ["rlib"]

system/gd/rust/linux/utils/src/lib.rs

+1 −0
Original line number Diff line number Diff line
@@ -4,4 +4,5 @@ pub mod adv_parser; 
pub mod array_utils;

pub mod cod;

pub mod socket;

pub mod uhid;

pub mod uinput;

system/gd/rust/linux/utils/src/uhid.rs

0 → 100644
+89 −0
Original line number Diff line number Diff line 
//! This library provides access to Linux uhid.



use log::{debug, error};

use std::fs::File;

use uhid_virt::{Bus, CreateParams, UHIDDevice};



const VID_DEFAULT: u32 = 0x0000;

const PID_DEFAULT: u32 = 0x0000;



// Report descriptor for a standard mouse

const RDESC: [u8; 50] = [

    0x05, 0x01, // USAGE_PAGE (Generic Desktop)

    0x09, 0x02, // USAGE (Mouse)

    0xa1, 0x01, // COLLECTION (Application)

    0x09, 0x01, //   USAGE (Pointer)

    0xa1, 0x00, //   COLLECTION (Physical)

    0x05, 0x09, //     USAGE_PAGE (Button)

    0x19, 0x01, //     USAGE_MINIMUM (Button 1)

    0x29, 0x03, //     USAGE_MAXIMUM (Button 3)

    0x15, 0x00, //     LOGICAL_MINIMUM (0)

    0x25, 0x01, //     LOGICAL_MAXIMUM (1)

    0x95, 0x03, //     REPORT_COUNT (3)

    0x75, 0x01, //     REPORT_SIZE (1)

    0x81, 0x02, //     INPUT (Data,Var,Abs)

    0x95, 0x01, //     REPORT_COUNT (1)

    0x75, 0x05, //     REPORT_SIZE (5)

    0x81, 0x03, //     INPUT (Cnst,Var,Abs)

    0x05, 0x01, //     USAGE_PAGE (Generic Desktop)

    0x09, 0x30, //     USAGE (X)

    0x09, 0x31, //     USAGE (Y)

    0x15, 0x81, //     LOGICAL_MINIMUM (-127)

    0x25, 0x7f, //     LOGICAL_MAXIMUM (127)

    0x75, 0x08, //     REPORT_SIZE (8)

    0x95, 0x02, //     REPORT_COUNT (2)

    0x81, 0x06, //     INPUT (Data,Var,Rel)

    0xc0, //   END_COLLECTION

    0xc0, // END_COLLECTION

];



pub struct UHid {

    /// Open UHID objects.

    devices: Vec<UHIDDevice<File>>,

}



impl Drop for UHid {

    fn drop(&mut self) {

        self.clear();

    }

}



impl UHid {

    /// Create a new UHid struct that holds a vector of uhid objects.

    pub fn new() -> Self {

        UHid { devices: Vec::<UHIDDevice<File>>::new() }

    }



    /// Initialize a uhid device with kernel.

    pub fn create(&mut self, name: String, phys: String, uniq: String) -> Result<(), String> {

        debug!("Create a UHID {} with phys: {}, uniq: {}", name, phys, uniq);

        let rd_data = RDESC.to_vec();

        let create_params = CreateParams {

            name: name,

            phys: phys,

            uniq: uniq,

            bus: Bus::BLUETOOTH,

            vendor: VID_DEFAULT,

            product: PID_DEFAULT,

            version: 0,

            country: 0,

            rd_data,

        };

        match UHIDDevice::create(create_params) {

            Ok(d) => self.devices.push(d),

            Err(e) => return Err(e.to_string()),

        }

        Ok(())

    }



    /// Destroy open UHID devices and clear the storage.

    pub fn clear(&mut self) {

        for device in self.devices.iter_mut() {

            match device.destroy() {

                Err(e) => error!("Fail to destroy uhid {}", e),

                Ok(_) => (),

            }

        }

        self.devices.clear();

    }

}