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

Commit 2faf872f authored by Zach Johnson's avatar Zach Johnson Committed by Automerger Merge Worker
Browse files

Merge changes Ie08faff0,I0356c210,Ie591460e,I51b88fc9 am: ee34dec6 am: 703f719a

Original change: https://android-review.googlesource.com/c/platform/system/bt/+/1527475

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I1857c5038e455dd3b34663510d12941b2f95cacf
parents 190d1b36 703f719a
Loading
Loading
Loading
Loading
+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 {";
+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();
            }
        });
+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! {
+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 {
+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
Loading