1 //! HCI layer facade
2
3 use crate::{EventRegistry, RawCommandSender};
4 use bt_common::GrpcFacade;
5 use bt_facade_helpers::RxAdapter;
6 use bt_facade_proto::common::Data;
7 use bt_facade_proto::empty::Empty;
8 use bt_facade_proto::hci_facade::EventRequest;
9 use bt_facade_proto::hci_facade_grpc::{create_hci_facade, HciFacade};
10 use bt_hal::AclHal;
11 use bt_hal::IsoHal;
12 use bt_packets::hci::{
13 AclPacket, CommandPacket, EventCode, EventPacket, IsoPacket, LeMetaEventPacket, SubeventCode,
14 };
15 use gddi::{module, provides, Stoppable};
16 use grpcio::*;
17 use num_traits::FromPrimitive;
18 use tokio::sync::mpsc::{channel, Sender};
19
20 module! {
21 facade_module,
22 providers {
23 HciFacadeService => provide_facade,
24 }
25 }
26
27 #[provides]
provide_facade( commands: RawCommandSender, events: EventRegistry, acl: AclHal, iso: IsoHal, ) -> HciFacadeService28 async fn provide_facade(
29 commands: RawCommandSender,
30 events: EventRegistry,
31 acl: AclHal,
32 iso: IsoHal,
33 ) -> HciFacadeService {
34 let (evt_tx, evt_rx) = channel::<EventPacket>(10);
35 let (le_evt_tx, le_evt_rx) = channel::<LeMetaEventPacket>(10);
36 HciFacadeService {
37 commands,
38 events,
39 evt_tx,
40 evt_rx: RxAdapter::new(evt_rx),
41 le_evt_tx,
42 le_evt_rx: RxAdapter::new(le_evt_rx),
43 acl_tx: acl.tx,
44 acl_rx: RxAdapter::from_arc(acl.rx),
45 iso_tx: iso.tx,
46 iso_rx: RxAdapter::from_arc(iso.rx),
47 }
48 }
49
50 /// HCI layer facade service
51 #[allow(missing_docs)]
52 #[derive(Clone, Stoppable)]
53 pub struct HciFacadeService {
54 pub commands: RawCommandSender,
55 events: EventRegistry,
56 evt_tx: Sender<EventPacket>,
57 pub evt_rx: RxAdapter<EventPacket>,
58 le_evt_tx: Sender<LeMetaEventPacket>,
59 pub le_evt_rx: RxAdapter<LeMetaEventPacket>,
60 pub acl_tx: Sender<AclPacket>,
61 pub acl_rx: RxAdapter<AclPacket>,
62 pub iso_tx: Sender<IsoPacket>,
63 pub iso_rx: RxAdapter<IsoPacket>,
64 }
65
66 impl HciFacadeService {
67 /// Register for the event & plug in the channel to get them back on
register_event(&mut self, code: u32)68 pub async fn register_event(&mut self, code: u32) {
69 self.events.register(EventCode::from_u32(code).unwrap(), self.evt_tx.clone()).await;
70 }
71
72 /// Register for the le event & plug in the channel to get them back on
register_le_event(&mut self, code: u32)73 pub async fn register_le_event(&mut self, code: u32) {
74 self.events
75 .register_le(SubeventCode::from_u32(code).unwrap(), self.le_evt_tx.clone())
76 .await;
77 }
78 }
79
80 impl GrpcFacade for HciFacadeService {
into_grpc(self) -> grpcio::Service81 fn into_grpc(self) -> grpcio::Service {
82 create_hci_facade(self)
83 }
84 }
85
86 impl HciFacade for HciFacadeService {
send_command(&mut self, ctx: RpcContext<'_>, mut data: Data, sink: UnarySink<Empty>)87 fn send_command(&mut self, ctx: RpcContext<'_>, mut data: Data, sink: UnarySink<Empty>) {
88 let packet = CommandPacket::parse(&data.take_payload()).unwrap();
89 let mut commands = self.commands.clone();
90 let evt_tx = self.evt_tx.clone();
91 ctx.spawn(async move {
92 sink.success(Empty::default()).await.unwrap();
93 let response = commands.send(packet).await.unwrap();
94 evt_tx.send(response).await.unwrap();
95 });
96 }
97
request_event(&mut self, ctx: RpcContext<'_>, req: EventRequest, sink: UnarySink<Empty>)98 fn request_event(&mut self, ctx: RpcContext<'_>, req: EventRequest, sink: UnarySink<Empty>) {
99 let mut clone = self.clone();
100 ctx.spawn(async move {
101 clone.register_event(req.get_code()).await;
102 sink.success(Empty::default()).await.unwrap();
103 });
104 }
105
request_le_subevent( &mut self, ctx: RpcContext<'_>, req: EventRequest, sink: UnarySink<Empty>, )106 fn request_le_subevent(
107 &mut self,
108 ctx: RpcContext<'_>,
109 req: EventRequest,
110 sink: UnarySink<Empty>,
111 ) {
112 let mut clone = self.clone();
113 ctx.spawn(async move {
114 clone.register_le_event(req.get_code()).await;
115 sink.success(Empty::default()).await.unwrap();
116 });
117 }
118
send_acl(&mut self, ctx: RpcContext<'_>, mut packet: Data, sink: UnarySink<Empty>)119 fn send_acl(&mut self, ctx: RpcContext<'_>, mut packet: Data, sink: UnarySink<Empty>) {
120 let acl_tx = self.acl_tx.clone();
121 ctx.spawn(async move {
122 acl_tx.send(AclPacket::parse(&packet.take_payload()).unwrap()).await.unwrap();
123 sink.success(Empty::default()).await.unwrap();
124 });
125 }
126
stream_events(&mut self, ctx: RpcContext<'_>, _req: Empty, sink: ServerStreamingSink<Data>)127 fn stream_events(&mut self, ctx: RpcContext<'_>, _req: Empty, sink: ServerStreamingSink<Data>) {
128 self.evt_rx.stream_grpc(ctx, sink);
129 }
130
stream_le_subevents( &mut self, ctx: RpcContext<'_>, _req: Empty, sink: ServerStreamingSink<Data>, )131 fn stream_le_subevents(
132 &mut self,
133 ctx: RpcContext<'_>,
134 _req: Empty,
135 sink: ServerStreamingSink<Data>,
136 ) {
137 self.le_evt_rx.stream_grpc(ctx, sink);
138 }
139
stream_acl(&mut self, ctx: RpcContext<'_>, _req: Empty, sink: ServerStreamingSink<Data>)140 fn stream_acl(&mut self, ctx: RpcContext<'_>, _req: Empty, sink: ServerStreamingSink<Data>) {
141 self.acl_rx.stream_grpc(ctx, sink);
142 }
143 }
144