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

Commit ee34dec6 authored by Zach Johnson's avatar Zach Johnson Committed by Gerrit Code Review
Browse files

Merge changes Ie08faff0,I0356c210,Ie591460e,I51b88fc9 

* changes:
  rusty-gd: update command sending to match cpp-gd
  rusty-gd: simplify hci a little bit
  rusty-gd: simplify some packet usages
  rusty-gd: improve ergonomics of converting packets to vectors
parents 9fdf54bc 13c39e6a

system/gd/packet/parser/packet_def.cc

+2 −0
Original line number Diff line number Diff line
@@ -960,6 +960,8 @@ void PacketDef::GenRustAccessStructImpls(std::ostream& s) const { 
  s << " buffer.freeze()";

  s << "}\n";



  s << "pub fn to_vec(self) -> Vec<u8> { self.to_bytes().to_vec() }\n";



  if (!children_.empty()) {

    s << " pub fn specialize(&self) -> " << name_ << "Child {";

    s << " match &self." << util::CamelCaseToUnderScore(name_) << ".child {";

system/gd/rust/hal/src/facade.rs

+2 −2
Original line number Diff line number Diff line
@@ -82,7 +82,7 @@ impl HciHalFacade for HciHalFacadeService { 
        self.rt.spawn(async move {

            while let Some(event) = evt_rx.lock().await.recv().await {

                let mut output = Data::default();

                output.set_payload(event.to_bytes().to_vec());

                output.set_payload(event.to_vec());

                sink.send((output, WriteFlags::default())).await.unwrap();

            }

        });
@@ -93,7 +93,7 @@ impl HciHalFacade for HciHalFacadeService { 
        self.rt.spawn(async move {

            while let Some(acl) = acl_rx.lock().await.recv().await {

                let mut output = Data::default();

                output.set_payload(acl.to_bytes().to_vec());

                output.set_payload(acl.to_vec());

                sink.send((output, WriteFlags::default())).await.unwrap();

            }

        });

system/gd/rust/hal/src/hidl_hal.rs

+7 −7
Original line number Diff line number Diff line 
//! Implementation of the HAl that talks to BT controller over Android's HIDL

use crate::internal::{Hal, RawHalExports};

use bt_packets::hci;

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use gddi::{module, provides};

use std::sync::Arc;

use std::sync::Mutex;
@@ -53,8 +53,8 @@ mod ffi { 


struct Callbacks {

    init_tx: UnboundedSender<()>,

    evt_tx: UnboundedSender<hci::EventPacket>,

    acl_tx: UnboundedSender<hci::AclPacket>,

    evt_tx: UnboundedSender<EventPacket>,

    acl_tx: UnboundedSender<AclPacket>,

}



lazy_static! {
@@ -72,7 +72,7 @@ fn on_event(data: &[u8]) { 
        .as_ref()

        .unwrap()

        .evt_tx

        .send(hci::EventPacket::parse(data).unwrap())

        .send(EventPacket::parse(data).unwrap())

        .unwrap();

}
@@ -82,15 +82,15 @@ fn on_acl(data: &[u8]) { 
        .as_ref()

        .unwrap()

        .acl_tx

        .send(hci::AclPacket::parse(data).unwrap())

        .send(AclPacket::parse(data).unwrap())

        .unwrap();

}



fn on_sco(_data: &[u8]) {}



async fn dispatch_outgoing(

    mut cmd_rx: UnboundedReceiver<hci::CommandPacket>,

    mut acl_rx: UnboundedReceiver<hci::AclPacket>,

    mut cmd_rx: UnboundedReceiver<CommandPacket>,

    mut acl_rx: UnboundedReceiver<AclPacket>,

) {

    loop {

        select! {

system/gd/rust/hal/src/lib.rs

+14 −14
Original line number Diff line number Diff line
@@ -12,7 +12,7 @@ pub mod snoop; 
#[cfg(target_os = "android")]

mod hidl_hal;



use bt_packets::hci;

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use gddi::{module, Stoppable};

use std::sync::Arc;

use thiserror::Error;
@@ -47,17 +47,17 @@ const H4_HEADER_SIZE: usize = 1; 
#[derive(Clone, Stoppable)]

pub struct HalExports {

    /// Transmit end of a channel used to send HCI commands

    pub cmd_tx: Sender<hci::CommandPacket>,

    pub cmd_tx: Sender<CommandPacket>,

    /// Receive end of a channel used to receive HCI events

    pub evt_rx: Arc<Mutex<Receiver<hci::EventPacket>>>,

    pub evt_rx: Arc<Mutex<Receiver<EventPacket>>>,

    /// Transmit end of a channel used to send ACL data

    pub acl_tx: Sender<hci::AclPacket>,

    pub acl_tx: Sender<AclPacket>,

    /// Receive end of a channel used to receive ACL data

    pub acl_rx: Arc<Mutex<Receiver<hci::AclPacket>>>,

    pub acl_rx: Arc<Mutex<Receiver<AclPacket>>>,

}



mod internal {

    use bt_packets::hci;

    use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

    use gddi::Stoppable;

    use std::sync::Arc;

    use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
@@ -65,17 +65,17 @@ mod internal { 


    #[derive(Clone, Stoppable)]

    pub struct RawHalExports {

        pub cmd_tx: UnboundedSender<hci::CommandPacket>,

        pub evt_rx: Arc<Mutex<UnboundedReceiver<hci::EventPacket>>>,

        pub acl_tx: UnboundedSender<hci::AclPacket>,

        pub acl_rx: Arc<Mutex<UnboundedReceiver<hci::AclPacket>>>,

        pub cmd_tx: UnboundedSender<CommandPacket>,

        pub evt_rx: Arc<Mutex<UnboundedReceiver<EventPacket>>>,

        pub acl_tx: UnboundedSender<AclPacket>,

        pub acl_rx: Arc<Mutex<UnboundedReceiver<AclPacket>>>,

    }



    pub struct Hal {

        pub cmd_rx: UnboundedReceiver<hci::CommandPacket>,

        pub evt_tx: UnboundedSender<hci::EventPacket>,

        pub acl_rx: UnboundedReceiver<hci::AclPacket>,

        pub acl_tx: UnboundedSender<hci::AclPacket>,

        pub cmd_rx: UnboundedReceiver<CommandPacket>,

        pub evt_tx: UnboundedSender<EventPacket>,

        pub acl_rx: UnboundedReceiver<AclPacket>,

        pub acl_tx: UnboundedSender<AclPacket>,

    }



    impl Hal {

system/gd/rust/hal/src/rootcanal_hal.rs

+12 −8
Original line number Diff line number Diff line
@@ -4,9 +4,10 @@ 


use crate::internal::{Hal, RawHalExports};

use crate::{Result, H4_HEADER_SIZE};

use bt_packets::hci;

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use bytes::{BufMut, Bytes, BytesMut};

use gddi::{module, provides, Stoppable};

use num_derive::{FromPrimitive, ToPrimitive};

use std::net::{IpAddr, SocketAddr};

use std::str::FromStr;

use std::sync::Arc;
@@ -15,7 +16,6 @@ use tokio::net::TcpStream; 
use tokio::runtime::Runtime;

use tokio::select;

use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};

use num_derive::{FromPrimitive, ToPrimitive};



#[derive(FromPrimitive, ToPrimitive)]

enum HciPacketType {
@@ -76,8 +76,8 @@ impl RootcanalConfig { 


/// Send HCI events received from the HAL to the HCI layer

async fn dispatch_incoming<R>(

    evt_tx: UnboundedSender<hci::EventPacket>,

    acl_tx: UnboundedSender<hci::AclPacket>,

    evt_tx: UnboundedSender<EventPacket>,

    acl_tx: UnboundedSender<AclPacket>,

    reader: R,

) -> Result<()>

where
@@ -96,7 +96,9 @@ where 
            payload.resize(len, 0);

            reader.read_exact(&mut payload).await?;

            buffer.unsplit(payload);

            evt_tx.send(hci::EventPacket::parse(&buffer.freeze()).unwrap()).unwrap();

            evt_tx

                .send(EventPacket::parse(&buffer.freeze()).unwrap())

                .unwrap();

        } else if buffer[0] == HciPacketType::Acl as u8 {

            buffer.resize(HciPacketHeaderSize::Acl as usize, 0);

            reader.read_exact(&mut buffer).await?;
@@ -105,15 +107,17 @@ where 
            payload.resize(len, 0);

            reader.read_exact(&mut payload).await?;

            buffer.unsplit(payload);

            acl_tx.send(hci::AclPacket::parse(&buffer.freeze()).unwrap()).unwrap();

            acl_tx

                .send(AclPacket::parse(&buffer.freeze()).unwrap())

                .unwrap();

        }

    }

}



/// Send commands received from the HCI later to rootcanal

async fn dispatch_outgoing<W>(

    mut cmd_rx: UnboundedReceiver<hci::CommandPacket>,

    mut acl_rx: UnboundedReceiver<hci::AclPacket>,

    mut cmd_rx: UnboundedReceiver<CommandPacket>,

    mut acl_rx: UnboundedReceiver<AclPacket>,

    mut writer: W,

) -> Result<()>

where