pub mod facade;
use bt_hal::HalExports;
-use bt_packets::hci;
-use bt_packets::hci::EventChild::{CommandStatus,CommandComplete};
+use bt_packets::hci::EventChild::{CommandComplete, CommandStatus};
+use bt_packets::hci::{AclPacket, CommandPacket, EventCode, EventPacket, OpCode};
use error::Result;
use gddi::{module, provides, Stoppable};
use std::collections::HashMap;
/// to the command is received
#[derive(Debug)]
struct Command {
- cmd: hci::CommandPacket,
- fut: oneshot::Sender<hci::EventPacket>,
+ cmd: CommandPacket,
+ fut: oneshot::Sender<EventPacket>,
}
#[derive(Debug)]
struct PendingCommand {
- opcode: hci::OpCode,
- fut: oneshot::Sender<hci::EventPacket>,
+ opcode: OpCode,
+ fut: oneshot::Sender<EventPacket>,
}
/// HCI interface
#[derive(Clone, Stoppable)]
pub struct HciExports {
cmd_tx: Sender<Command>,
- evt_handlers: Arc<Mutex<HashMap<hci::EventCode, Sender<hci::EventPacket>>>>,
+ evt_handlers: Arc<Mutex<HashMap<EventCode, Sender<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>>>,
}
impl HciExports {
- async fn send(&mut self, cmd: hci::CommandPacket) -> Result<hci::EventPacket> {
- let (tx, rx) = oneshot::channel::<hci::EventPacket>();
+ async fn send(&mut self, cmd: CommandPacket) -> Result<EventPacket> {
+ let (tx, rx) = oneshot::channel::<EventPacket>();
self.cmd_tx.send(Command { cmd, fut: tx }).await?;
let event = rx.await?;
Ok(event)
/// Enqueue an HCI command expecting a command complete
/// response from the controller
- pub async fn enqueue_command_with_complete(&mut self, cmd: hci::CommandPacket) -> hci::EventPacket {
+ pub async fn enqueue_command_with_complete(&mut self, cmd: CommandPacket) -> EventPacket {
self.send(cmd).await.unwrap()
}
/// Enqueue an HCI command expecting a status response
/// from the controller
- pub async fn enqueue_command_with_status(&mut self, cmd: hci::CommandPacket) -> hci::EventPacket {
+ pub async fn enqueue_command_with_status(&mut self, cmd: CommandPacket) -> EventPacket {
self.send(cmd).await.unwrap()
}
/// Indicate interest in specific HCI events
- pub async fn register_event_handler(&mut self, evt_code: hci::EventCode, sender: Sender<hci::EventPacket>) {
+ pub async fn register_event_handler(
+ &mut self,
+ evt_code: EventCode,
+ sender: Sender<EventPacket>,
+ ) {
self.evt_handlers.lock().await.insert(evt_code, sender);
}
}
async fn dispatch(
- evt_handlers: Arc<Mutex<HashMap<hci::EventCode, Sender<hci::EventPacket>>>>,
- evt_rx: Arc<Mutex<Receiver<hci::EventPacket>>>,
- cmd_tx: Sender<hci::CommandPacket>,
+ evt_handlers: Arc<Mutex<HashMap<EventCode, Sender<EventPacket>>>>,
+ evt_rx: Arc<Mutex<Receiver<EventPacket>>>,
+ cmd_tx: Sender<CommandPacket>,
mut cmd_rx: Receiver<Command>,
) {
let mut pending_cmds: Vec<PendingCommand> = Vec::new();
}
}
-async fn consume(evt_rx: &Arc<Mutex<Receiver<hci::EventPacket>>>) -> Option<hci::EventPacket> {
+async fn consume(evt_rx: &Arc<Mutex<Receiver<EventPacket>>>) -> Option<EventPacket> {
evt_rx.lock().await.recv().await
}