1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bluetooth_sapphire/internal/host/testing/test_packets.h"
16
17 #include "pw_bluetooth/hci_common.emb.h"
18 #include "pw_bluetooth/hci_data.emb.h"
19 #include "pw_bluetooth_sapphire/internal/host/common/byte_buffer.h"
20 #include "pw_bluetooth_sapphire/internal/host/hci-spec/constants.h"
21 #include "pw_bluetooth_sapphire/internal/host/hci-spec/protocol.h"
22 #include "pw_bluetooth_sapphire/internal/host/hci-spec/vendor_protocol.h"
23 #include "pw_bluetooth_sapphire/internal/host/hci/bredr_connection_request.h"
24 #include "pw_bluetooth_sapphire/internal/host/testing/test_helpers.h"
25 #include "pw_string/string_builder.h"
26
27 namespace bt::testing {
28
29 namespace android_hci = bt::hci_spec::vendor::android;
30 namespace android_emb = pw::bluetooth::vendor::android_hci;
31
AcceptConnectionRequestPacket(DeviceAddress address)32 DynamicByteBuffer AcceptConnectionRequestPacket(DeviceAddress address) {
33 const auto addr = address.value().bytes();
34 return DynamicByteBuffer(StaticByteBuffer(
35 LowerBits(hci_spec::kAcceptConnectionRequest),
36 UpperBits(hci_spec::kAcceptConnectionRequest),
37 0x07, // parameter_total_size (7 bytes)
38 // peer BD_ADDR (6 bytes)
39 addr[0],
40 addr[1],
41 addr[2],
42 addr[3],
43 addr[4],
44 addr[5],
45 0x00 // Role (Become central)
46 ));
47 }
48
AuthenticationRequestedPacket(hci_spec::ConnectionHandle conn)49 DynamicByteBuffer AuthenticationRequestedPacket(
50 hci_spec::ConnectionHandle conn) {
51 return DynamicByteBuffer(StaticByteBuffer(
52 LowerBits(hci_spec::kAuthenticationRequested),
53 UpperBits(hci_spec::kAuthenticationRequested),
54 0x02, // parameter_total_size (2 bytes)
55 LowerBits(conn), // Connection_Handle
56 UpperBits(conn) // Connection_Handle
57 ));
58 }
59
CommandCompletePacket(hci_spec::OpCode opcode,pw::bluetooth::emboss::StatusCode status)60 DynamicByteBuffer CommandCompletePacket(
61 hci_spec::OpCode opcode, pw::bluetooth::emboss::StatusCode status) {
62 return DynamicByteBuffer(StaticByteBuffer(
63 hci_spec::kCommandCompleteEventCode,
64 0x04, // parameter_total_size (4 bytes)
65 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
66 LowerBits(opcode), // Command_Opcode
67 UpperBits(opcode), // Command_Opcode
68 status // Status
69 ));
70 }
71
CommandStatusPacket(hci_spec::OpCode op_code,pw::bluetooth::emboss::StatusCode status_code,uint8_t num_packets)72 DynamicByteBuffer CommandStatusPacket(
73 hci_spec::OpCode op_code,
74 pw::bluetooth::emboss::StatusCode status_code,
75 uint8_t num_packets) {
76 return DynamicByteBuffer(StaticByteBuffer(
77 hci_spec::kCommandStatusEventCode,
78 0x04, // parameter_total_size (4 bytes)
79 status_code, // Status
80 num_packets, // Num_HCI_Command_Packets allowed to be sent to controller
81 LowerBits(op_code), // Command_Opcode
82 UpperBits(op_code) // Command_Opcode
83 ));
84 }
85
ConnectionCompletePacket(DeviceAddress address,hci_spec::ConnectionHandle conn,pw::bluetooth::emboss::StatusCode status)86 DynamicByteBuffer ConnectionCompletePacket(
87 DeviceAddress address,
88 hci_spec::ConnectionHandle conn,
89 pw::bluetooth::emboss::StatusCode status) {
90 const auto addr = address.value().bytes();
91 return DynamicByteBuffer(StaticByteBuffer(
92 hci_spec::kConnectionCompleteEventCode,
93 0x0B, // parameter_total_size (11 bytes)
94 status, // Status
95 LowerBits(conn), // Connection_Handle
96 UpperBits(conn), // Connection_Handle
97 // peer BD_ADDR (6 bytes)
98 addr[0],
99 addr[1],
100 addr[2],
101 addr[3],
102 addr[4],
103 addr[5],
104 0x01, // Link_Type (ACL)
105 0x00 // Encryption_Enabled (Disabled)
106 ));
107 }
108
ConnectionRequestPacket(DeviceAddress address,hci_spec::LinkType link_type)109 DynamicByteBuffer ConnectionRequestPacket(DeviceAddress address,
110 hci_spec::LinkType link_type) {
111 const auto addr = address.value().bytes();
112 return DynamicByteBuffer(StaticByteBuffer(
113 hci_spec::kConnectionRequestEventCode,
114 0x0A, // parameter_total_size (10 bytes)
115 // peer BD_ADDR (6 bytes)
116 addr[0],
117 addr[1],
118 addr[2],
119 addr[3],
120 addr[4],
121 addr[5],
122 0x5A, // Class_Of_Device
123 0x42, // (Smart Phone minor class)
124 0x0C, // Networking, Capturing, Object Transfer, Telephony, LE Audio
125 link_type // Link_Type
126 ));
127 }
128
CreateConnectionPacket(DeviceAddress address)129 DynamicByteBuffer CreateConnectionPacket(DeviceAddress address) {
130 const auto addr = address.value().bytes();
131 return DynamicByteBuffer(StaticByteBuffer(
132 LowerBits(hci_spec::kCreateConnection),
133 UpperBits(hci_spec::kCreateConnection),
134 0x0d, // parameter_total_size (13 bytes)
135 // peer BD_ADDR (6 bytes)
136 addr[0],
137 addr[1],
138 addr[2],
139 addr[3],
140 addr[4],
141 addr[5],
142 LowerBits(hci::kEnableAllPacketTypes), // Packet_Type
143 UpperBits(hci::kEnableAllPacketTypes), // Packet_Type
144 0x02, // Page_Scan_Repetition_Mode (R2)
145 0x00, // Reserved
146 0x00, // Clock_Offset
147 0x00, // Clock_Offset
148 0x00 // Allow_Role_Switch (Not allowed)
149 ));
150 }
151
CreateConnectionCancelPacket(DeviceAddress address)152 DynamicByteBuffer CreateConnectionCancelPacket(DeviceAddress address) {
153 const auto addr = address.value().bytes();
154 return DynamicByteBuffer(
155 StaticByteBuffer(LowerBits(hci_spec::kCreateConnectionCancel),
156 UpperBits(hci_spec::kCreateConnectionCancel),
157 0x06, // parameter_total_size (6 bytes)
158 // peer BD_ADDR (6 bytes)
159 addr[0],
160 addr[1],
161 addr[2],
162 addr[3],
163 addr[4],
164 addr[5]));
165 }
166
DisconnectionCompletePacket(hci_spec::ConnectionHandle conn,pw::bluetooth::emboss::StatusCode reason)167 DynamicByteBuffer DisconnectionCompletePacket(
168 hci_spec::ConnectionHandle conn, pw::bluetooth::emboss::StatusCode reason) {
169 return DynamicByteBuffer(StaticByteBuffer(
170 hci_spec::kDisconnectionCompleteEventCode,
171 0x04, // parameter_total_size (4 bytes)
172 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
173 LowerBits(conn), // Connection_Handle
174 UpperBits(conn), // Connection_Handle
175 reason // Reason
176 ));
177 }
178
DisconnectPacket(hci_spec::ConnectionHandle conn,pw::bluetooth::emboss::StatusCode reason)179 DynamicByteBuffer DisconnectPacket(hci_spec::ConnectionHandle conn,
180 pw::bluetooth::emboss::StatusCode reason) {
181 return DynamicByteBuffer(StaticByteBuffer(
182 LowerBits(hci_spec::kDisconnect),
183 UpperBits(hci_spec::kDisconnect),
184 0x03, // parameter_total_size (3 bytes)
185 LowerBits(conn), // Connection_Handle
186 UpperBits(conn), // Connection_Handle
187 reason // Reason
188 ));
189 }
190
DisconnectStatusResponsePacket()191 DynamicByteBuffer DisconnectStatusResponsePacket() {
192 return DynamicByteBuffer(StaticByteBuffer(
193 hci_spec::kCommandStatusEventCode,
194 0x04, // parameter_total_size (3 bytes)
195 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
196 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
197 LowerBits(hci_spec::kDisconnect), // Command_Opcode
198 UpperBits(hci_spec::kDisconnect) // Command_Opcode
199 ));
200 }
201
EmptyCommandPacket(hci_spec::OpCode opcode)202 DynamicByteBuffer EmptyCommandPacket(hci_spec::OpCode opcode) {
203 return DynamicByteBuffer(
204 StaticByteBuffer(LowerBits(opcode), UpperBits(opcode), /*length=*/0));
205 }
206
EncryptionChangeEventPacket(pw::bluetooth::emboss::StatusCode status_code,hci_spec::ConnectionHandle conn,hci_spec::EncryptionStatus encryption_enabled)207 DynamicByteBuffer EncryptionChangeEventPacket(
208 pw::bluetooth::emboss::StatusCode status_code,
209 hci_spec::ConnectionHandle conn,
210 hci_spec::EncryptionStatus encryption_enabled) {
211 return DynamicByteBuffer(StaticByteBuffer(
212 hci_spec::kEncryptionChangeEventCode,
213 0x04, // parameter_total_size (4 bytes)
214 status_code, // Status
215 LowerBits(conn), // Connection_Handle
216 UpperBits(conn), // Connection_Handle
217 static_cast<uint8_t>(encryption_enabled) // Encryption_Enabled
218 ));
219 }
220
EnhancedAcceptSynchronousConnectionRequestPacket(DeviceAddress peer_address,bt::StaticPacket<pw::bluetooth::emboss::SynchronousConnectionParametersWriter> params)221 DynamicByteBuffer EnhancedAcceptSynchronousConnectionRequestPacket(
222 DeviceAddress peer_address,
223 bt::StaticPacket<
224 pw::bluetooth::emboss::SynchronousConnectionParametersWriter> params) {
225 auto packet = hci::CommandPacket::New<
226 pw::bluetooth::emboss::
227 EnhancedAcceptSynchronousConnectionRequestCommandWriter>(
228 hci_spec::kEnhancedAcceptSynchronousConnectionRequest);
229 auto view = packet.view_t();
230
231 view.bd_addr().CopyFrom(peer_address.value().view());
232 view.connection_parameters().CopyFrom(params.view());
233
234 return DynamicByteBuffer(packet.data());
235 }
236
EnhancedSetupSynchronousConnectionPacket(hci_spec::ConnectionHandle conn,bt::StaticPacket<pw::bluetooth::emboss::SynchronousConnectionParametersWriter> params)237 DynamicByteBuffer EnhancedSetupSynchronousConnectionPacket(
238 hci_spec::ConnectionHandle conn,
239 bt::StaticPacket<
240 pw::bluetooth::emboss::SynchronousConnectionParametersWriter> params) {
241 auto packet = hci::CommandPacket::New<
242 pw::bluetooth::emboss::EnhancedSetupSynchronousConnectionCommandWriter>(
243 hci_spec::kEnhancedSetupSynchronousConnection);
244
245 auto view = packet.view_t();
246 view.connection_handle().Write(conn);
247 view.connection_parameters().CopyFrom(params.view());
248
249 return DynamicByteBuffer(packet.data());
250 }
251
InquiryCommandPacket(uint16_t inquiry_length)252 DynamicByteBuffer InquiryCommandPacket(uint16_t inquiry_length) {
253 return DynamicByteBuffer(StaticByteBuffer(
254 LowerBits(hci_spec::kInquiry),
255 UpperBits(hci_spec::kInquiry),
256 0x05, // parameter_total_size (5 bytes)
257 0x33, // LAP (GIAC)
258 0x8B, // LAP (GIAC)
259 0x9E, // LAP (GIAC)
260 inquiry_length, // Inquiry_Length
261 0x00 // Num_Responses (Unlimited)
262 ));
263 }
264
IoCapabilityRequestNegativeReplyPacket(DeviceAddress address,pw::bluetooth::emboss::StatusCode status_code)265 DynamicByteBuffer IoCapabilityRequestNegativeReplyPacket(
266 DeviceAddress address, pw::bluetooth::emboss::StatusCode status_code) {
267 const auto addr = address.value().bytes();
268 return DynamicByteBuffer(StaticByteBuffer(
269 LowerBits(hci_spec::kIOCapabilityRequestNegativeReply),
270 UpperBits(hci_spec::kIOCapabilityRequestNegativeReply),
271 0x07, // parameter_total_size (7 bytes)
272 // peer BD_ADDR (6 bytes)
273 addr[0],
274 addr[1],
275 addr[2],
276 addr[3],
277 addr[4],
278 addr[5],
279 status_code // Reason
280 ));
281 }
282
IoCapabilityRequestNegativeReplyResponse(DeviceAddress address)283 DynamicByteBuffer IoCapabilityRequestNegativeReplyResponse(
284 DeviceAddress address) {
285 const auto addr = address.value().bytes();
286 return DynamicByteBuffer(StaticByteBuffer(
287 hci_spec::kCommandCompleteEventCode,
288 0x0A, // parameter_total_size (10 bytes)
289 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
290 LowerBits(hci_spec::kIOCapabilityRequestNegativeReply), // Command_Opcode
291 UpperBits(hci_spec::kIOCapabilityRequestNegativeReply), // Command_Opcode
292 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
293 // peer BD_ADDR (6 bytes)
294 addr[0],
295 addr[1],
296 addr[2],
297 addr[3],
298 addr[4],
299 addr[5]));
300 }
301
IoCapabilityRequestPacket(DeviceAddress address)302 DynamicByteBuffer IoCapabilityRequestPacket(DeviceAddress address) {
303 const auto addr = address.value().bytes();
304 return DynamicByteBuffer(
305 StaticByteBuffer(hci_spec::kIOCapabilityRequestEventCode,
306 0x06, // parameter_total_size (6 bytes)
307 // peer BD_ADDR (6 bytes)
308 addr[0],
309 addr[1],
310 addr[2],
311 addr[3],
312 addr[4],
313 addr[5]));
314 }
315
IoCapabilityRequestReplyPacket(DeviceAddress address,pw::bluetooth::emboss::IoCapability io_cap,pw::bluetooth::emboss::AuthenticationRequirements auth_req)316 DynamicByteBuffer IoCapabilityRequestReplyPacket(
317 DeviceAddress address,
318 pw::bluetooth::emboss::IoCapability io_cap,
319 pw::bluetooth::emboss::AuthenticationRequirements auth_req) {
320 const auto addr = address.value().bytes();
321 return DynamicByteBuffer(StaticByteBuffer(
322 LowerBits(hci_spec::kIOCapabilityRequestReply),
323 UpperBits(hci_spec::kIOCapabilityRequestReply),
324 0x09, // parameter_total_size (9 bytes)
325 // peer BD_ADDR (6 bytes)
326 addr[0],
327 addr[1],
328 addr[2],
329 addr[3],
330 addr[4],
331 addr[5],
332 io_cap, // IO_Capability
333 0x00, // OOB_Data_Present (Not present)
334 auth_req // Authentication_Requirements
335 ));
336 }
337
IoCapabilityRequestReplyResponse(DeviceAddress address)338 DynamicByteBuffer IoCapabilityRequestReplyResponse(DeviceAddress address) {
339 const auto addr = address.value().bytes();
340 return DynamicByteBuffer(StaticByteBuffer(
341 hci_spec::kCommandCompleteEventCode,
342 0x0A, // parameter_total_size (10 bytes)
343 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
344 LowerBits(hci_spec::kIOCapabilityRequestReply), // Command_Opcode
345 UpperBits(hci_spec::kIOCapabilityRequestReply), // Command_Opcode
346 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
347 // peer BD_ADDR (6 bytes)
348 addr[0],
349 addr[1],
350 addr[2],
351 addr[3],
352 addr[4],
353 addr[5]));
354 }
355
IoCapabilityResponsePacket(DeviceAddress address,pw::bluetooth::emboss::IoCapability io_cap,pw::bluetooth::emboss::AuthenticationRequirements auth_req)356 DynamicByteBuffer IoCapabilityResponsePacket(
357 DeviceAddress address,
358 pw::bluetooth::emboss::IoCapability io_cap,
359 pw::bluetooth::emboss::AuthenticationRequirements auth_req) {
360 const auto addr = address.value().bytes();
361 return DynamicByteBuffer(StaticByteBuffer(
362 hci_spec::kIOCapabilityResponseEventCode,
363 0x09, // parameter_total_size (9 bytes)
364 // peer BD_ADDR (6 bytes)
365 addr[0],
366 addr[1],
367 addr[2],
368 addr[3],
369 addr[4],
370 addr[5],
371 io_cap, // IO_Capability
372 0x00, // OOB_Data_Present (Not present)
373 auth_req // Authentication_Requirements
374 ));
375 }
376
IsoDataPacket(size_t frame_total_size,hci_spec::ConnectionHandle connection_handle,uint16_t packet_sequence_number)377 DynamicByteBuffer IsoDataPacket(size_t frame_total_size,
378 hci_spec::ConnectionHandle connection_handle,
379 uint16_t packet_sequence_number) {
380 DynamicByteBuffer packet(frame_total_size);
381 auto view = pw::bluetooth::emboss::MakeIsoDataFramePacketView(
382 packet.mutable_data(), frame_total_size);
383
384 const size_t data_total_length =
385 frame_total_size - view.header().IntrinsicSizeInBytes().Read();
386 view.header().connection_handle().Write(connection_handle);
387 view.header().pb_flag().Write(
388 pw::bluetooth::emboss::IsoDataPbFlag::COMPLETE_SDU);
389 view.header().ts_flag().Write(
390 pw::bluetooth::emboss::TsFlag::TIMESTAMP_NOT_PRESENT);
391 view.header().data_total_length().Write(data_total_length);
392
393 const size_t iso_sdu_length =
394 frame_total_size - view.sdu_fragment_offset().Read();
395 view.packet_sequence_number().Write(packet_sequence_number);
396 view.iso_sdu_length().Write(iso_sdu_length);
397 view.packet_status_flag().Write(
398 pw::bluetooth::emboss::IsoDataPacketStatus::VALID_DATA);
399
400 // Write payload
401 for (size_t n = 0; n < iso_sdu_length; n++) {
402 view.iso_sdu_fragment()[n].Write(static_cast<uint8_t>(n * 2));
403 }
404
405 return packet;
406 }
407
LEReadRemoteFeaturesCompletePacket(hci_spec::ConnectionHandle conn,hci_spec::LESupportedFeatures le_features)408 DynamicByteBuffer LEReadRemoteFeaturesCompletePacket(
409 hci_spec::ConnectionHandle conn,
410 hci_spec::LESupportedFeatures le_features) {
411 const BufferView features(&le_features, sizeof(le_features));
412 return DynamicByteBuffer(StaticByteBuffer(
413 hci_spec::kLEMetaEventCode,
414 0x0c, // parameter_total_size (12 bytes)
415 hci_spec::kLEReadRemoteFeaturesCompleteSubeventCode, // Subevent_Code
416 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
417 LowerBits(conn), // Connection_Handle
418 UpperBits(conn), // Connection_Handle
419 // LE_Features (8 bytes)
420 features[0],
421 features[1],
422 features[2],
423 features[3],
424 features[4],
425 features[5],
426 features[6],
427 features[7]));
428 }
429
LEReadRemoteFeaturesPacket(hci_spec::ConnectionHandle conn)430 DynamicByteBuffer LEReadRemoteFeaturesPacket(hci_spec::ConnectionHandle conn) {
431 return DynamicByteBuffer(StaticByteBuffer(
432 LowerBits(hci_spec::kLEReadRemoteFeatures),
433 UpperBits(hci_spec::kLEReadRemoteFeatures),
434 0x02, // parameter_total_size (2 bytes)
435 LowerBits(conn), // Connection_Handle
436 UpperBits(conn) // Connection_Handle
437 ));
438 }
439
LECisRequestEventPacket(hci_spec::ConnectionHandle acl_connection_handle,hci_spec::ConnectionHandle cis_connection_handle,hci_spec::CigIdentifier cig_id,hci_spec::CisIdentifier cis_id)440 DynamicByteBuffer LECisRequestEventPacket(
441 hci_spec::ConnectionHandle acl_connection_handle,
442 hci_spec::ConnectionHandle cis_connection_handle,
443 hci_spec::CigIdentifier cig_id,
444 hci_spec::CisIdentifier cis_id) {
445 return DynamicByteBuffer(StaticByteBuffer(
446 hci_spec::kLEMetaEventCode,
447 0x07, // parameter_total_size (7 bytes)
448 hci_spec::kLECISRequestSubeventCode, // Subevent_Code
449 LowerBits(acl_connection_handle), // ACL_Connection_Handle
450 UpperBits(acl_connection_handle), // ACL_Connection_Handle
451 LowerBits(cis_connection_handle), // CIS_Connection_Handle
452 UpperBits(cis_connection_handle), // CIS_Connection_Handle
453 cig_id, // CIG_ID
454 cis_id) // CIS_ID
455 );
456 }
457
LEAcceptCisRequestCommandPacket(hci_spec::ConnectionHandle cis_handle)458 DynamicByteBuffer LEAcceptCisRequestCommandPacket(
459 hci_spec::ConnectionHandle cis_handle) {
460 return DynamicByteBuffer(
461 StaticByteBuffer(LowerBits(hci_spec::kLEAcceptCISRequest),
462 UpperBits(hci_spec::kLEAcceptCISRequest),
463 0x02,
464 LowerBits(cis_handle),
465 UpperBits(cis_handle)));
466 }
467
LERejectCisRequestCommandPacket(hci_spec::ConnectionHandle cis_handle,pw::bluetooth::emboss::StatusCode reason)468 DynamicByteBuffer LERejectCisRequestCommandPacket(
469 hci_spec::ConnectionHandle cis_handle,
470 pw::bluetooth::emboss::StatusCode reason) {
471 return DynamicByteBuffer(
472 StaticByteBuffer(LowerBits(hci_spec::kLERejectCISRequest),
473 UpperBits(hci_spec::kLERejectCISRequest),
474 0x03, // parameter_total_size (3 bytes)
475 LowerBits(cis_handle), // Connection_Handle
476 UpperBits(cis_handle), // Connection_Handle
477 reason) // Reason
478 );
479 }
480
LERequestPeerScaCompletePacket(hci_spec::ConnectionHandle conn,pw::bluetooth::emboss::LESleepClockAccuracyRange sca)481 DynamicByteBuffer LERequestPeerScaCompletePacket(
482 hci_spec::ConnectionHandle conn,
483 pw::bluetooth::emboss::LESleepClockAccuracyRange sca) {
484 auto packet = hci::EventPacket::New<
485 pw::bluetooth::emboss::LERequestPeerSCACompleteSubeventWriter>(
486 hci_spec::kLEMetaEventCode);
487
488 auto view = packet.view_t();
489 view.le_meta_event().subevent_code().Write(
490 hci_spec::kLERequestPeerSCACompleteSubeventCode);
491 view.status().Write(pw::bluetooth::emboss::StatusCode::SUCCESS);
492 view.connection_handle().Write(conn);
493 view.peer_clock_accuracy().Write(sca);
494
495 return DynamicByteBuffer(packet.data());
496 }
497
LECisEstablishedEventPacket(pw::bluetooth::emboss::StatusCode status,hci_spec::ConnectionHandle connection_handle,uint32_t cig_sync_delay_us,uint32_t cis_sync_delay_us,uint32_t transport_latency_c_to_p_us,uint32_t transport_latency_p_to_c_us,pw::bluetooth::emboss::IsoPhyType phy_c_to_p,pw::bluetooth::emboss::IsoPhyType phy_p_to_c,uint8_t nse,uint8_t bn_c_to_p,uint8_t bn_p_to_c,uint8_t ft_c_to_p,uint8_t ft_p_to_c,uint16_t max_pdu_c_to_p,uint16_t max_pdu_p_to_c,uint16_t iso_interval)498 DynamicByteBuffer LECisEstablishedEventPacket(
499 pw::bluetooth::emboss::StatusCode status,
500 hci_spec::ConnectionHandle connection_handle,
501 uint32_t cig_sync_delay_us,
502 uint32_t cis_sync_delay_us,
503 uint32_t transport_latency_c_to_p_us,
504 uint32_t transport_latency_p_to_c_us,
505 pw::bluetooth::emboss::IsoPhyType phy_c_to_p,
506 pw::bluetooth::emboss::IsoPhyType phy_p_to_c,
507 uint8_t nse,
508 uint8_t bn_c_to_p,
509 uint8_t bn_p_to_c,
510 uint8_t ft_c_to_p,
511 uint8_t ft_p_to_c,
512 uint16_t max_pdu_c_to_p,
513 uint16_t max_pdu_p_to_c,
514 uint16_t iso_interval) {
515 auto packet = hci::EventPacket::New<
516 pw::bluetooth::emboss::LECISEstablishedSubeventWriter>(
517 hci_spec::kLEMetaEventCode);
518 auto view = packet.view_t();
519
520 view.le_meta_event().subevent_code().Write(
521 hci_spec::kLECISEstablishedSubeventCode);
522 view.status().Write(status);
523 view.connection_handle().Write(connection_handle);
524 view.cig_sync_delay().Write(cig_sync_delay_us);
525 view.cis_sync_delay().Write(cis_sync_delay_us);
526 view.transport_latency_c_to_p().Write(transport_latency_c_to_p_us);
527 view.transport_latency_p_to_c().Write(transport_latency_p_to_c_us);
528 view.phy_c_to_p().Write(phy_c_to_p);
529 view.phy_p_to_c().Write(phy_p_to_c);
530 view.nse().Write(nse);
531 view.bn_c_to_p().Write(bn_c_to_p);
532 view.bn_p_to_c().Write(bn_p_to_c);
533 view.ft_c_to_p().Write(ft_c_to_p);
534 view.ft_p_to_c().Write(ft_p_to_c);
535 view.max_pdu_c_to_p().Write(max_pdu_c_to_p);
536 view.max_pdu_p_to_c().Write(max_pdu_p_to_c);
537 view.iso_interval().Write(iso_interval);
538
539 return DynamicByteBuffer(packet.data());
540 }
541
LESetupIsoDataPathPacket(hci_spec::ConnectionHandle connection_handle,pw::bluetooth::emboss::DataPathDirection direction,uint8_t data_path_id,bt::StaticPacket<pw::bluetooth::emboss::CodecIdWriter> codec_id,uint32_t controller_delay,const std::optional<std::vector<uint8_t>> & codec_configuration)542 DynamicByteBuffer LESetupIsoDataPathPacket(
543 hci_spec::ConnectionHandle connection_handle,
544 pw::bluetooth::emboss::DataPathDirection direction,
545 uint8_t data_path_id,
546 bt::StaticPacket<pw::bluetooth::emboss::CodecIdWriter> codec_id,
547 uint32_t controller_delay,
548 const std::optional<std::vector<uint8_t>>& codec_configuration) {
549 size_t packet_size =
550 pw::bluetooth::emboss::LESetupISODataPathCommand::MinSizeInBytes() +
551 (codec_configuration.has_value() ? codec_configuration->size() : 0);
552 auto packet = hci::CommandPacket::New<
553 pw::bluetooth::emboss::LESetupISODataPathCommandWriter>(
554 hci_spec::kLESetupISODataPath, packet_size);
555 auto view = packet.view_t();
556 view.connection_handle().Write(connection_handle);
557 view.data_path_direction().Write(direction);
558 view.data_path_id().Write(data_path_id);
559 view.codec_id().CopyFrom(
560 const_cast<bt::StaticPacket<pw::bluetooth::emboss::CodecIdWriter>&>(
561 codec_id)
562 .view());
563 view.controller_delay().Write(controller_delay);
564 if (codec_configuration.has_value()) {
565 view.codec_configuration_length().Write(codec_configuration->size());
566 std::memcpy(view.codec_configuration().BackingStorage().data(),
567 codec_configuration->data(),
568 codec_configuration->size());
569 } else {
570 view.codec_configuration_length().Write(0);
571 }
572 return DynamicByteBuffer(packet.data());
573 }
574
LESetupIsoDataPathResponse(pw::bluetooth::emboss::StatusCode status,hci_spec::ConnectionHandle connection_handle)575 DynamicByteBuffer LESetupIsoDataPathResponse(
576 pw::bluetooth::emboss::StatusCode status,
577 hci_spec::ConnectionHandle connection_handle) {
578 return DynamicByteBuffer(StaticByteBuffer(
579 hci_spec::kCommandCompleteEventCode,
580 0x06, // parameter_total_size (6 bytes)
581 0xF0, // Num_HCI_CommandPackets allowed to be sent to controller (240)
582 LowerBits(hci_spec::kLESetupISODataPath),
583 UpperBits(hci_spec::kLESetupISODataPath),
584 status,
585 LowerBits(connection_handle),
586 UpperBits(connection_handle)));
587 }
588
LERequestPeerScaPacket(hci_spec::ConnectionHandle conn)589 DynamicByteBuffer LERequestPeerScaPacket(hci_spec::ConnectionHandle conn) {
590 auto packet = hci::CommandPacket::New<
591 pw::bluetooth::emboss::LERequestPeerSCACommandWriter>(
592 hci_spec::kLERequestPeerSCA);
593 auto view = packet.view_t();
594 view.connection_handle().Write(conn);
595 return DynamicByteBuffer(packet.data());
596 }
597
LEStartEncryptionPacket(hci_spec::ConnectionHandle conn,uint64_t random_number,uint16_t encrypted_diversifier,UInt128 ltk)598 DynamicByteBuffer LEStartEncryptionPacket(hci_spec::ConnectionHandle conn,
599 uint64_t random_number,
600 uint16_t encrypted_diversifier,
601 UInt128 ltk) {
602 const BufferView rand(&random_number, sizeof(random_number));
603 return DynamicByteBuffer(StaticByteBuffer(
604 LowerBits(hci_spec::kLEStartEncryption),
605 UpperBits(hci_spec::kLEStartEncryption),
606 0x1c, // parameter_total_size (28 bytes)
607 LowerBits(conn), // Connection_Handle
608 UpperBits(conn), // Connection_Handle
609 // Random_Number (8 bytes)
610 rand[0],
611 rand[1],
612 rand[2],
613 rand[3],
614 rand[4],
615 rand[5],
616 rand[6],
617 rand[7],
618 LowerBits(encrypted_diversifier), // Encrypted_Diversifier
619 UpperBits(encrypted_diversifier), // Encrypted_Diversifier
620 // Long_Term_Key (16 bytes)
621 ltk[0],
622 ltk[1],
623 ltk[2],
624 ltk[3],
625 ltk[4],
626 ltk[5],
627 ltk[6],
628 ltk[7],
629 ltk[8],
630 ltk[9],
631 ltk[10],
632 ltk[11],
633 ltk[12],
634 ltk[13],
635 ltk[14],
636 ltk[15]));
637 }
638
LinkKeyNotificationPacket(DeviceAddress address,UInt128 link_key,hci_spec::LinkKeyType key_type)639 DynamicByteBuffer LinkKeyNotificationPacket(DeviceAddress address,
640 UInt128 link_key,
641 hci_spec::LinkKeyType key_type) {
642 const auto addr = address.value().bytes();
643 return DynamicByteBuffer(StaticByteBuffer(
644 hci_spec::kLinkKeyNotificationEventCode,
645 0x17, // parameter_total_size (23 bytes)
646 // peer BD_ADDR (6 bytes)
647 addr[0],
648 addr[1],
649 addr[2],
650 addr[3],
651 addr[4],
652 addr[5],
653 // Link_Key (16 bytes)
654 link_key[0],
655 link_key[1],
656 link_key[2],
657 link_key[3],
658 link_key[4],
659 link_key[5],
660 link_key[6],
661 link_key[7],
662 link_key[8],
663 link_key[9],
664 link_key[10],
665 link_key[11],
666 link_key[12],
667 link_key[13],
668 link_key[14],
669 link_key[15],
670 key_type // Key_Type
671 ));
672 }
673
LinkKeyRequestPacket(DeviceAddress address)674 DynamicByteBuffer LinkKeyRequestPacket(DeviceAddress address) {
675 const auto addr = address.value().bytes();
676 return DynamicByteBuffer(
677 StaticByteBuffer(hci_spec::kLinkKeyRequestEventCode,
678 0x06, // parameter_total_size (6 bytes)
679 // peer BD_ADDR (6 bytes)
680 addr[0],
681 addr[1],
682 addr[2],
683 addr[3],
684 addr[4],
685 addr[5]));
686 }
687
LinkKeyRequestNegativeReplyPacket(DeviceAddress address)688 DynamicByteBuffer LinkKeyRequestNegativeReplyPacket(DeviceAddress address) {
689 const auto addr = address.value().bytes();
690 return DynamicByteBuffer(
691 StaticByteBuffer(LowerBits(hci_spec::kLinkKeyRequestNegativeReply),
692 UpperBits(hci_spec::kLinkKeyRequestNegativeReply),
693 0x06, // parameter_total_size (6 bytes)
694 // peer BD_ADDR (6 bytes)
695 addr[0],
696 addr[1],
697 addr[2],
698 addr[3],
699 addr[4],
700 addr[5]));
701 }
702
LinkKeyRequestNegativeReplyResponse(DeviceAddress address)703 DynamicByteBuffer LinkKeyRequestNegativeReplyResponse(DeviceAddress address) {
704 const auto addr = address.value().bytes();
705 return DynamicByteBuffer(StaticByteBuffer(
706 hci_spec::kCommandCompleteEventCode,
707 0x0A, // parameter_total_size (10 bytes)
708 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
709 LowerBits(hci_spec::kLinkKeyRequestNegativeReply), // Command_Opcode
710 UpperBits(hci_spec::kLinkKeyRequestNegativeReply), // Command_Opcode
711 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
712 // peer BD_ADDR (6 bytes)
713 addr[0],
714 addr[1],
715 addr[2],
716 addr[3],
717 addr[4],
718 addr[5]));
719 }
720
LinkKeyRequestReplyPacket(DeviceAddress address,UInt128 link_key)721 DynamicByteBuffer LinkKeyRequestReplyPacket(DeviceAddress address,
722 UInt128 link_key) {
723 const auto addr = address.value().bytes();
724 return DynamicByteBuffer(
725 StaticByteBuffer(LowerBits(hci_spec::kLinkKeyRequestReply),
726 UpperBits(hci_spec::kLinkKeyRequestReply),
727 0x16, // parameter_total_size (22 bytes)
728 // peer BD_ADDR (6 bytes)
729 addr[0],
730 addr[1],
731 addr[2],
732 addr[3],
733 addr[4],
734 addr[5],
735 // Link_Key (16 bytes)
736 link_key[0],
737 link_key[1],
738 link_key[2],
739 link_key[3],
740 link_key[4],
741 link_key[5],
742 link_key[6],
743 link_key[7],
744 link_key[8],
745 link_key[9],
746 link_key[10],
747 link_key[11],
748 link_key[12],
749 link_key[13],
750 link_key[14],
751 link_key[15]));
752 }
753
LinkKeyRequestReplyResponse(DeviceAddress address)754 DynamicByteBuffer LinkKeyRequestReplyResponse(DeviceAddress address) {
755 const auto addr = address.value().bytes();
756 return DynamicByteBuffer(StaticByteBuffer(
757 hci_spec::kCommandCompleteEventCode,
758 0x0A, // parameter_total_size (10 bytes)
759 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
760 LowerBits(hci_spec::kLinkKeyRequestReply), // Command_Opcode
761 UpperBits(hci_spec::kLinkKeyRequestReply), // Command_Opcode
762 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
763 // peer BD_ADDR (6 bytes)
764 addr[0],
765 addr[1],
766 addr[2],
767 addr[3],
768 addr[4],
769 addr[5]));
770 }
771
NumberOfCompletedPacketsPacket(hci_spec::ConnectionHandle conn,uint16_t num_packets)772 DynamicByteBuffer NumberOfCompletedPacketsPacket(
773 hci_spec::ConnectionHandle conn, uint16_t num_packets) {
774 return DynamicByteBuffer(StaticByteBuffer(
775 0x13,
776 0x05, // Number Of Completed Packet HCI event header, parameters length
777 0x01, // Num_Handles
778 LowerBits(conn), // Connection_Handle
779 UpperBits(conn), // Connection_Handle
780 LowerBits(num_packets), // Num_Completed_Packets
781 UpperBits(num_packets) // Num_Completed_Packets
782 ));
783 }
784
PinCodeRequestPacket(DeviceAddress address)785 DynamicByteBuffer PinCodeRequestPacket(DeviceAddress address) {
786 const auto addr = address.value().bytes();
787 return DynamicByteBuffer(
788 StaticByteBuffer(hci_spec::kPinCodeRequestEventCode,
789 0x06, // parameter_total_size (6 bytes)
790 // peer BD_ADDR (6 bytes)
791 addr[0],
792 addr[1],
793 addr[2],
794 addr[3],
795 addr[4],
796 addr[5]));
797 }
798
PinCodeRequestNegativeReplyPacket(DeviceAddress address)799 DynamicByteBuffer PinCodeRequestNegativeReplyPacket(DeviceAddress address) {
800 const auto addr = address.value().bytes();
801 return DynamicByteBuffer(
802 StaticByteBuffer(LowerBits(hci_spec::kPinCodeRequestNegativeReply),
803 UpperBits(hci_spec::kPinCodeRequestNegativeReply),
804 0x06, // parameter_total_size (6 bytes)
805 // peer BD_ADDR (6 bytes)
806 addr[0],
807 addr[1],
808 addr[2],
809 addr[3],
810 addr[4],
811 addr[5]));
812 }
813
PinCodeRequestNegativeReplyResponse(DeviceAddress address)814 DynamicByteBuffer PinCodeRequestNegativeReplyResponse(DeviceAddress address) {
815 const auto addr = address.value().bytes();
816 return DynamicByteBuffer(StaticByteBuffer(
817 hci_spec::kCommandCompleteEventCode,
818 0x0A, // parameter_total_size (10 bytes)
819 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
820 LowerBits(hci_spec::kPinCodeRequestNegativeReply), // Command_Opcode
821 UpperBits(hci_spec::kPinCodeRequestNegativeReply), // Command_Opcode
822 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
823 // peer BD_ADDR (6 bytes)
824 addr[0],
825 addr[1],
826 addr[2],
827 addr[3],
828 addr[4],
829 addr[5]));
830 }
831
PinCodeRequestReplyPacket(DeviceAddress address,uint8_t pin_length,std::string pin_code)832 DynamicByteBuffer PinCodeRequestReplyPacket(DeviceAddress address,
833 uint8_t pin_length,
834 std::string pin_code) {
835 const auto addr = address.value().bytes();
836
837 StaticByteBuffer<16> pin;
838 pin.Write(BufferView(pin_code));
839
840 return DynamicByteBuffer(
841 StaticByteBuffer(LowerBits(hci_spec::kPinCodeRequestReply),
842 UpperBits(hci_spec::kPinCodeRequestReply),
843 0x17, // parameter_total_size (23 bytes)
844 // peer BD_ADDR (6 bytes)
845 addr[0],
846 addr[1],
847 addr[2],
848 addr[3],
849 addr[4],
850 addr[5],
851 pin_length, // PIN_Code_Length
852 // PIN_Code
853 pin[0],
854 pin[1],
855 pin[2],
856 pin[3],
857 pin[4],
858 pin[5],
859 pin[6],
860 pin[7],
861 pin[8],
862 pin[9],
863 pin[10],
864 pin[11],
865 pin[12],
866 pin[13],
867 pin[14],
868 pin[15]));
869 }
870
PinCodeRequestReplyResponse(DeviceAddress address)871 DynamicByteBuffer PinCodeRequestReplyResponse(DeviceAddress address) {
872 const auto addr = address.value().bytes();
873 return DynamicByteBuffer(StaticByteBuffer(
874 hci_spec::kCommandCompleteEventCode,
875 0x0A, // parameter_total_size (10 bytes)
876 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
877 LowerBits(hci_spec::kPinCodeRequestReply), // Command_Opcode
878 UpperBits(hci_spec::kPinCodeRequestReply), // Command_Opcode
879 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
880 // peer BD_ADDR (6 bytes)
881 addr[0],
882 addr[1],
883 addr[2],
884 addr[3],
885 addr[4],
886 addr[5]));
887 }
888
ReadRemoteExtended1CompletePacket(hci_spec::ConnectionHandle conn)889 DynamicByteBuffer ReadRemoteExtended1CompletePacket(
890 hci_spec::ConnectionHandle conn) {
891 return DynamicByteBuffer(StaticByteBuffer(
892 hci_spec::kReadRemoteExtendedFeaturesCompleteEventCode,
893 0x0D, // parameter_total_size (13 bytes)
894 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
895 LowerBits(conn), // Connection_Handle
896 UpperBits(conn), // Connection_Handle
897 0x01, // Page_Number
898 0x03, // Max_Page_Number (3 pages)
899 // Extended_LMP_Features (8 bytes)
900 0x0F,
901 0x00,
902 0x00,
903 0x00,
904 0x00,
905 0x00,
906 0x00,
907 0x00
908 // lmp_features_page1: Secure Simple Pairing (Host Support), LE Supported
909 // (Host), Previously used, Secure Connections (Host Support)
910 ));
911 }
912
ReadRemoteExtended1CompletePacketNoSsp(hci_spec::ConnectionHandle conn)913 DynamicByteBuffer ReadRemoteExtended1CompletePacketNoSsp(
914 hci_spec::ConnectionHandle conn) {
915 return DynamicByteBuffer(StaticByteBuffer(
916 hci_spec::kReadRemoteExtendedFeaturesCompleteEventCode,
917 0x0D, // parameter_total_size (13 bytes)
918 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
919 LowerBits(conn), // Connection_Handle
920 UpperBits(conn), // Connection_Handle
921 0x01, // Page_Number
922 0x03, // Max_Page_Number (3 pages)
923 // Extended_LMP_Features (8 bytes)
924 0x0E,
925 0x00,
926 0x00,
927 0x00,
928 0x00,
929 0x00,
930 0x00,
931 0x00
932 // lmp_features_page1: LE Supported (Host), Previously used, Secure
933 // Connections (Host Support)
934 ));
935 }
936
ReadRemoteExtended1Packet(hci_spec::ConnectionHandle conn)937 DynamicByteBuffer ReadRemoteExtended1Packet(hci_spec::ConnectionHandle conn) {
938 return DynamicByteBuffer(StaticByteBuffer(
939 LowerBits(hci_spec::kReadRemoteExtendedFeatures),
940 UpperBits(hci_spec::kReadRemoteExtendedFeatures),
941 0x03, // parameter_total_size (3 bytes)
942 LowerBits(conn), // Connection_Handle
943 UpperBits(conn), // Connection_Handle
944 0x01 // Page_Number (1)
945 ));
946 }
947
ReadRemoteExtended2CompletePacket(hci_spec::ConnectionHandle conn)948 DynamicByteBuffer ReadRemoteExtended2CompletePacket(
949 hci_spec::ConnectionHandle conn) {
950 return DynamicByteBuffer(StaticByteBuffer(
951 hci_spec::kReadRemoteExtendedFeaturesCompleteEventCode,
952 0x0D, // parameter_total_size (13 bytes)
953 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
954 LowerBits(conn), // Connection_Handle
955 UpperBits(conn), // Connection_Handle
956 0x02, // Page_Number
957 0x03, // Max_Page_Number (3 pages)
958 // Extended_LMP_Features (8 bytes)
959 0x00,
960 0x00,
961 0x00,
962 0x00,
963 0x02,
964 0x00,
965 0xFF,
966 0x00
967 // lmp_features_page2: All the bits should be ignored
968 ));
969 }
970
ReadRemoteExtended2Packet(hci_spec::ConnectionHandle conn)971 DynamicByteBuffer ReadRemoteExtended2Packet(hci_spec::ConnectionHandle conn) {
972 return DynamicByteBuffer(StaticByteBuffer(
973 LowerBits(hci_spec::kReadRemoteExtendedFeatures),
974 UpperBits(hci_spec::kReadRemoteExtendedFeatures),
975 0x03, // parameter_total_size (3 bytes)
976 LowerBits(conn), // Connection_Handle
977 UpperBits(conn), // Connection_Handle
978 0x02 // Page_Number (2)
979 ));
980 }
981
ReadRemoteVersionInfoCompletePacket(hci_spec::ConnectionHandle conn)982 DynamicByteBuffer ReadRemoteVersionInfoCompletePacket(
983 hci_spec::ConnectionHandle conn) {
984 return DynamicByteBuffer(StaticByteBuffer(
985 hci_spec::kReadRemoteVersionInfoCompleteEventCode,
986 0x08, // parameter_total_size (8 bytes)
987 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
988 LowerBits(conn), // Connection_Handle
989 UpperBits(conn), // Connection_Handle
990 pw::bluetooth::emboss::CoreSpecificationVersion::V4_2, // Version
991 0xE0, // Company_Identifier (Google)
992 0x00, // Company_Identifier (Google)
993 0xAD, // Subversion (Anything)
994 0xDE // Subversion (Anything)
995 ));
996 }
997
ReadRemoteVersionInfoPacket(hci_spec::ConnectionHandle conn)998 DynamicByteBuffer ReadRemoteVersionInfoPacket(hci_spec::ConnectionHandle conn) {
999 return DynamicByteBuffer(StaticByteBuffer(
1000 LowerBits(hci_spec::kReadRemoteVersionInfo),
1001 UpperBits(hci_spec::kReadRemoteVersionInfo),
1002 0x02, // parameter_total_size (2 bytes)
1003 LowerBits(conn), // Connection_Handle
1004 UpperBits(conn) // Connection_Handle
1005 ));
1006 }
1007
ReadRemoteSupportedFeaturesCompletePacket(hci_spec::ConnectionHandle conn,bool extended_features)1008 DynamicByteBuffer ReadRemoteSupportedFeaturesCompletePacket(
1009 hci_spec::ConnectionHandle conn, bool extended_features) {
1010 return DynamicByteBuffer(StaticByteBuffer(
1011 hci_spec::kReadRemoteSupportedFeaturesCompleteEventCode,
1012 0x0B, // parameter_total_size (11 bytes)
1013 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
1014 LowerBits(conn), // Connection_Handle
1015 UpperBits(conn), // Connection_Handle
1016 // LMP_Features (8 bytes)
1017 0xFF,
1018 0x00,
1019 0x00,
1020 0x00,
1021 0x04,
1022 0x00,
1023 0x08,
1024 (extended_features ? 0x80 : 0x00)
1025 // lmp_features_page0: 3 slot packets, 5 slot packets, Encryption, Slot
1026 // Offset, Timing Accuracy, Role Switch, Hold Mode, Sniff Mode, LE
1027 // Supported (Controller), Secure Simple Pairing (Controller Support),
1028 // Extended Features if enabled
1029 ));
1030 }
1031
ReadRemoteSupportedFeaturesPacket(hci_spec::ConnectionHandle conn)1032 DynamicByteBuffer ReadRemoteSupportedFeaturesPacket(
1033 hci_spec::ConnectionHandle conn) {
1034 return DynamicByteBuffer(StaticByteBuffer(
1035 LowerBits(hci_spec::kReadRemoteSupportedFeatures),
1036 UpperBits(hci_spec::kReadRemoteSupportedFeatures),
1037 0x02, // parameter_total_size (2 bytes)
1038 LowerBits(conn), // Connection_Handle
1039 UpperBits(conn) // Connection_Handle
1040 ));
1041 }
1042
ReadScanEnable()1043 DynamicByteBuffer ReadScanEnable() {
1044 return DynamicByteBuffer(StaticByteBuffer(
1045 LowerBits(hci_spec::kReadScanEnable),
1046 UpperBits(hci_spec::kReadScanEnable),
1047 0x00 // No parameters
1048 ));
1049 }
1050
ReadScanEnableResponse(uint8_t scan_enable)1051 DynamicByteBuffer ReadScanEnableResponse(uint8_t scan_enable) {
1052 return DynamicByteBuffer(StaticByteBuffer(
1053 hci_spec::kCommandCompleteEventCode,
1054 0x05, // parameter_total_size (5 bytes)
1055 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
1056 LowerBits(hci_spec::kReadScanEnable), // Command_Opcode
1057 UpperBits(hci_spec::kReadScanEnable), // Command_Opcode
1058 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
1059 scan_enable // Scan_Enable
1060 ));
1061 }
1062
RejectConnectionRequestPacket(DeviceAddress address,pw::bluetooth::emboss::StatusCode reason)1063 DynamicByteBuffer RejectConnectionRequestPacket(
1064 DeviceAddress address, pw::bluetooth::emboss::StatusCode reason) {
1065 const auto addr = address.value().bytes();
1066 return DynamicByteBuffer(StaticByteBuffer(
1067 LowerBits(hci_spec::kRejectConnectionRequest),
1068 UpperBits(hci_spec::kRejectConnectionRequest),
1069 0x07, // parameter_total_size (7 bytes)
1070 // peer BD_ADDR (6 bytes)
1071 addr[0],
1072 addr[1],
1073 addr[2],
1074 addr[3],
1075 addr[4],
1076 addr[5],
1077 reason // Reason
1078 ));
1079 }
RejectSynchronousConnectionRequest(DeviceAddress address,pw::bluetooth::emboss::StatusCode status_code)1080 DynamicByteBuffer RejectSynchronousConnectionRequest(
1081 DeviceAddress address, pw::bluetooth::emboss::StatusCode status_code) {
1082 const auto addr = address.value().bytes();
1083 return DynamicByteBuffer(StaticByteBuffer(
1084 LowerBits(hci_spec::kRejectSynchronousConnectionRequest),
1085 UpperBits(hci_spec::kRejectSynchronousConnectionRequest),
1086 0x07, // parameter_total_size (7 bytes)
1087 // peer BD_ADDR (6 bytes)
1088 addr[0],
1089 addr[1],
1090 addr[2],
1091 addr[3],
1092 addr[4],
1093 addr[5],
1094 status_code // Reason
1095 ));
1096 }
1097
RemoteNameRequestCompletePacket(DeviceAddress address,const std::string & name)1098 DynamicByteBuffer RemoteNameRequestCompletePacket(DeviceAddress address,
1099 const std::string& name) {
1100 const auto addr = address.value().bytes();
1101 auto event = DynamicByteBuffer(
1102 pw::bluetooth::emboss::RemoteNameRequestCompleteEventView::
1103 IntrinsicSizeInBytes()
1104 .Read());
1105 event.SetToZeros();
1106 const StaticByteBuffer header(
1107 hci_spec::kRemoteNameRequestCompleteEventCode,
1108 0xff, // parameter_total_size (255 bytes)
1109 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
1110 // peer BD_ADDR (6 bytes)
1111 addr[0],
1112 addr[1],
1113 addr[2],
1114 addr[3],
1115 addr[4],
1116 addr[5]);
1117 header.Copy(&event);
1118 event.Write(reinterpret_cast<const uint8_t*>(name.data()),
1119 name.size(),
1120 header.size());
1121 return event;
1122 }
1123
RemoteNameRequestPacket(DeviceAddress address)1124 DynamicByteBuffer RemoteNameRequestPacket(DeviceAddress address) {
1125 const auto addr = address.value().bytes();
1126 return DynamicByteBuffer(StaticByteBuffer(
1127 LowerBits(hci_spec::kRemoteNameRequest),
1128 UpperBits(hci_spec::kRemoteNameRequest),
1129 0x0a, // parameter_total_size (10 bytes)
1130 // peer BD_ADDR (6 bytes)
1131 addr[0],
1132 addr[1],
1133 addr[2],
1134 addr[3],
1135 addr[4],
1136 addr[5],
1137 0x00, // Page_Scan_Repetition_Mode (R0)
1138 0x00, // Reserved
1139 0x00, // Clock_Offset
1140 0x00 // Clock_Offset
1141 ));
1142 }
1143
RoleChangePacket(DeviceAddress address,pw::bluetooth::emboss::ConnectionRole role,pw::bluetooth::emboss::StatusCode status)1144 DynamicByteBuffer RoleChangePacket(DeviceAddress address,
1145 pw::bluetooth::emboss::ConnectionRole role,
1146 pw::bluetooth::emboss::StatusCode status) {
1147 const auto addr = address.value().bytes();
1148 return DynamicByteBuffer(StaticByteBuffer(
1149 hci_spec::kRoleChangeEventCode,
1150 0x08, // parameter_total_size (8 bytes)
1151 status, // Status
1152 // peer BD_ADDR (6 bytes)
1153 addr[0],
1154 addr[1],
1155 addr[2],
1156 addr[3],
1157 addr[4],
1158 addr[5],
1159 role // Role
1160 ));
1161 }
1162
ScoDataPacket(hci_spec::ConnectionHandle conn,hci_spec::SynchronousDataPacketStatusFlag flag,const BufferView & payload,std::optional<uint8_t> payload_length_override)1163 DynamicByteBuffer ScoDataPacket(
1164 hci_spec::ConnectionHandle conn,
1165 hci_spec::SynchronousDataPacketStatusFlag flag,
1166 const BufferView& payload,
1167 std::optional<uint8_t> payload_length_override) {
1168 // Flag is bits 4-5 in the higher octet of |handle_and_flags|, i.e.
1169 // 0b00xx000000000000.
1170 conn |= static_cast<uint8_t>(flag) << 12;
1171 StaticByteBuffer header(
1172 LowerBits(conn),
1173 UpperBits(conn),
1174 payload_length_override ? *payload_length_override : payload.size());
1175 DynamicByteBuffer out(header.size() + payload.size());
1176 header.Copy(&out);
1177 MutableBufferView payload_view = out.mutable_view(header.size());
1178 payload.Copy(&payload_view);
1179 return out;
1180 }
1181
SetConnectionEncryption(hci_spec::ConnectionHandle conn,bool enable)1182 DynamicByteBuffer SetConnectionEncryption(hci_spec::ConnectionHandle conn,
1183 bool enable) {
1184 return DynamicByteBuffer(StaticByteBuffer(
1185 LowerBits(hci_spec::kSetConnectionEncryption),
1186 UpperBits(hci_spec::kSetConnectionEncryption),
1187 0x03, // parameter_total_size (3 bytes)
1188 LowerBits(conn), // Connection_Handle
1189 UpperBits(conn), // Connection_Handle
1190 static_cast<uint8_t>(enable) // Encryption_Enable
1191 ));
1192 }
1193
SimplePairingCompletePacket(DeviceAddress address,pw::bluetooth::emboss::StatusCode status_code)1194 DynamicByteBuffer SimplePairingCompletePacket(
1195 DeviceAddress address, pw::bluetooth::emboss::StatusCode status_code) {
1196 const auto addr = address.value().bytes();
1197 return DynamicByteBuffer(
1198 StaticByteBuffer(hci_spec::kSimplePairingCompleteEventCode,
1199 0x07, // parameter_total_size (7 bytes)
1200 status_code,
1201 // peer BD_ADDR (6 bytes)
1202 addr[0],
1203 addr[1],
1204 addr[2],
1205 addr[3],
1206 addr[4],
1207 addr[5]));
1208 }
1209
StartA2dpOffloadRequest(const l2cap::A2dpOffloadManager::Configuration & config,hci_spec::ConnectionHandle connection_handle,l2cap::ChannelId l2cap_channel_id,uint16_t l2cap_mtu_size)1210 DynamicByteBuffer StartA2dpOffloadRequest(
1211 const l2cap::A2dpOffloadManager::Configuration& config,
1212 hci_spec::ConnectionHandle connection_handle,
1213 l2cap::ChannelId l2cap_channel_id,
1214 uint16_t l2cap_mtu_size) {
1215 constexpr size_t kPacketSize =
1216 android_emb::StartA2dpOffloadCommand::MaxSizeInBytes();
1217 auto packet =
1218 hci::CommandPacket::New<android_emb::StartA2dpOffloadCommandWriter>(
1219 android_hci::kA2dpOffloadCommand, kPacketSize);
1220 auto view = packet.view_t();
1221
1222 view.vendor_command().sub_opcode().Write(
1223 android_hci::kStartA2dpOffloadCommandSubopcode);
1224 view.codec_type().Write(config.codec);
1225 view.max_latency().Write(config.max_latency);
1226 view.scms_t_enable().CopyFrom(
1227 const_cast<l2cap::A2dpOffloadManager::Configuration&>(config)
1228 .scms_t_enable.view());
1229 view.sampling_frequency().Write(config.sampling_frequency);
1230 view.bits_per_sample().Write(config.bits_per_sample);
1231 view.channel_mode().Write(config.channel_mode);
1232 view.encoded_audio_bitrate().Write(config.encoded_audio_bit_rate);
1233 view.connection_handle().Write(connection_handle);
1234 view.l2cap_channel_id().Write(l2cap_channel_id);
1235 view.l2cap_mtu_size().Write(l2cap_mtu_size);
1236
1237 switch (config.codec) {
1238 case android_emb::A2dpCodecType::SBC:
1239 view.sbc_codec_information().CopyFrom(
1240 const_cast<l2cap::A2dpOffloadManager::Configuration&>(config)
1241 .sbc_configuration.view());
1242 break;
1243 case android_emb::A2dpCodecType::AAC:
1244 view.aac_codec_information().CopyFrom(
1245 const_cast<l2cap::A2dpOffloadManager::Configuration&>(config)
1246 .aac_configuration.view());
1247 break;
1248 case android_emb::A2dpCodecType::LDAC:
1249 view.ldac_codec_information().CopyFrom(
1250 const_cast<l2cap::A2dpOffloadManager::Configuration&>(config)
1251 .ldac_configuration.view());
1252 break;
1253 default:
1254 break;
1255 }
1256
1257 return packet.release();
1258 }
1259
StopA2dpOffloadRequest()1260 DynamicByteBuffer StopA2dpOffloadRequest() {
1261 return DynamicByteBuffer(
1262 StaticByteBuffer(LowerBits(android_hci::kA2dpOffloadCommand),
1263 UpperBits(android_hci::kA2dpOffloadCommand),
1264 0x01, // parameter_total_size (1 byte)
1265 android_hci::kStopA2dpOffloadCommandSubopcode));
1266 }
1267
SynchronousConnectionCompletePacket(hci_spec::ConnectionHandle conn,DeviceAddress address,hci_spec::LinkType link_type,pw::bluetooth::emboss::StatusCode status)1268 DynamicByteBuffer SynchronousConnectionCompletePacket(
1269 hci_spec::ConnectionHandle conn,
1270 DeviceAddress address,
1271 hci_spec::LinkType link_type,
1272 pw::bluetooth::emboss::StatusCode status) {
1273 const auto addr = address.value().bytes();
1274 return DynamicByteBuffer(StaticByteBuffer(
1275 hci_spec::kSynchronousConnectionCompleteEventCode,
1276 0x11, // parameter_total_size (17 bytes)
1277 status, // Status
1278 LowerBits(conn), // Connection_Handle
1279 UpperBits(conn), // Connection_Handle
1280 // peer BD_ADDR (6 bytes)
1281 addr[0],
1282 addr[1],
1283 addr[2],
1284 addr[3],
1285 addr[4],
1286 addr[5],
1287 link_type, // Link_Type
1288 0x00, // Transmission_Interval interval
1289 0x00, // Retransmission_Window
1290 0x00, // RX_Packet_Length
1291 0x00, // RX_Packet_Length
1292 0x00, // TX_Packet_Length
1293 0x00, // TX_Packet_Length
1294 0x00 // Air_Mode
1295 ));
1296 }
1297
UserConfirmationRequestPacket(DeviceAddress address,uint32_t passkey)1298 DynamicByteBuffer UserConfirmationRequestPacket(DeviceAddress address,
1299 uint32_t passkey) {
1300 const auto addr = address.value().bytes();
1301 const auto passkey_bytes = ToBytes(passkey);
1302 return DynamicByteBuffer(StaticByteBuffer(
1303 hci_spec::kUserConfirmationRequestEventCode,
1304 0x0A, // parameter_total_size (10 bytes)
1305 // peer BD_ADDR (6 bytes)
1306 addr[0],
1307 addr[1],
1308 addr[2],
1309 addr[3],
1310 addr[4],
1311 addr[5],
1312 passkey_bytes[0], // Numeric_Value
1313 passkey_bytes[1], // Numeric_Value
1314 passkey_bytes[2], // Numeric_Value
1315 passkey_bytes[3] // Numeric_Value
1316 ));
1317 }
1318
UserConfirmationRequestNegativeReplyPacket(DeviceAddress address)1319 DynamicByteBuffer UserConfirmationRequestNegativeReplyPacket(
1320 DeviceAddress address) {
1321 const auto addr = address.value().bytes();
1322 return DynamicByteBuffer(StaticByteBuffer(
1323 LowerBits(hci_spec::kUserConfirmationRequestNegativeReply),
1324 UpperBits(hci_spec::kUserConfirmationRequestNegativeReply),
1325 0x06, // parameter_total_size (6 bytes)
1326 // peer BD_ADDR (6 bytes)
1327 addr[0],
1328 addr[1],
1329 addr[2],
1330 addr[3],
1331 addr[4],
1332 addr[5]));
1333 }
1334
UserConfirmationRequestReplyPacket(DeviceAddress address)1335 DynamicByteBuffer UserConfirmationRequestReplyPacket(DeviceAddress address) {
1336 const auto addr = address.value().bytes();
1337 return DynamicByteBuffer(
1338 StaticByteBuffer(LowerBits(hci_spec::kUserConfirmationRequestReply),
1339 UpperBits(hci_spec::kUserConfirmationRequestReply),
1340 0x06, // parameter_total_size (6 bytes)
1341 // peer BD_ADDR (6 bytes)
1342 addr[0],
1343 addr[1],
1344 addr[2],
1345 addr[3],
1346 addr[4],
1347 addr[5]));
1348 }
1349
UserPasskeyNotificationPacket(DeviceAddress address,uint32_t passkey)1350 DynamicByteBuffer UserPasskeyNotificationPacket(DeviceAddress address,
1351 uint32_t passkey) {
1352 const auto addr = address.value().bytes();
1353 const auto passkey_bytes = ToBytes(passkey);
1354 return DynamicByteBuffer(StaticByteBuffer(
1355 hci_spec::kUserPasskeyNotificationEventCode,
1356 0x0A, // parameter_total_size (10 bytes)
1357 // peer BD_ADDR (6 bytes)
1358 addr[0],
1359 addr[1],
1360 addr[2],
1361 addr[3],
1362 addr[4],
1363 addr[5],
1364 passkey_bytes[0], // Numeric_Value
1365 passkey_bytes[1], // Numeric_Value
1366 passkey_bytes[2], // Numeric_Value
1367 passkey_bytes[3] // Numeric_Value
1368 ));
1369 }
1370
UserPasskeyRequestNegativeReply(DeviceAddress address)1371 DynamicByteBuffer UserPasskeyRequestNegativeReply(DeviceAddress address) {
1372 const auto addr = address.value().bytes();
1373 return DynamicByteBuffer(
1374 StaticByteBuffer(LowerBits(hci_spec::kUserPasskeyRequestNegativeReply),
1375 UpperBits(hci_spec::kUserPasskeyRequestNegativeReply),
1376 0x06, // parameter_total_size (6 bytes)
1377 // peer BD_ADDR (6 bytes)
1378 addr[0],
1379 addr[1],
1380 addr[2],
1381 addr[3],
1382 addr[4],
1383 addr[5]));
1384 }
1385
UserPasskeyRequestNegativeReplyResponse(DeviceAddress address)1386 DynamicByteBuffer UserPasskeyRequestNegativeReplyResponse(
1387 DeviceAddress address) {
1388 const auto addr = address.value().bytes();
1389 return DynamicByteBuffer(StaticByteBuffer(
1390 hci_spec::kCommandCompleteEventCode,
1391 0x0A, // parameter_total_size (10 bytes)
1392 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
1393 LowerBits(hci_spec::kUserPasskeyRequestNegativeReply), // Command_Opcode
1394 UpperBits(hci_spec::kUserPasskeyRequestNegativeReply), // Command_Opcode
1395 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
1396 // peer BD_ADDR (6 bytes)
1397 addr[0],
1398 addr[1],
1399 addr[2],
1400 addr[3],
1401 addr[4],
1402 addr[5]));
1403 }
1404
UserPasskeyRequestPacket(DeviceAddress address)1405 DynamicByteBuffer UserPasskeyRequestPacket(DeviceAddress address) {
1406 const auto addr = address.value().bytes();
1407 return DynamicByteBuffer(
1408 StaticByteBuffer(hci_spec::kUserPasskeyRequestEventCode,
1409 0x06, // parameter_total_size (6 bytes)
1410 // peer BD_ADDR (6 bytes)
1411 addr[0],
1412 addr[1],
1413 addr[2],
1414 addr[3],
1415 addr[4],
1416 addr[5]));
1417 }
1418
UserPasskeyRequestReplyPacket(DeviceAddress address,uint32_t passkey)1419 DynamicByteBuffer UserPasskeyRequestReplyPacket(DeviceAddress address,
1420 uint32_t passkey) {
1421 const auto addr = address.value().bytes();
1422 const auto passkey_bytes = ToBytes(passkey);
1423 return DynamicByteBuffer(StaticByteBuffer(
1424 LowerBits(hci_spec::kUserPasskeyRequestReply),
1425 UpperBits(hci_spec::kUserPasskeyRequestReply),
1426 0x0A, // parameter_total_size (10 bytes)
1427 // peer BD_ADDR (6 bytes)
1428 addr[0],
1429 addr[1],
1430 addr[2],
1431 addr[3],
1432 addr[4],
1433 addr[5],
1434 passkey_bytes[0], // Numeric_Value
1435 passkey_bytes[1], // Numeric_Value
1436 passkey_bytes[2], // Numeric_Value
1437 passkey_bytes[3] // Numeric_Value
1438 ));
1439 }
1440
UserPasskeyRequestReplyResponse(DeviceAddress address)1441 DynamicByteBuffer UserPasskeyRequestReplyResponse(DeviceAddress address) {
1442 const auto addr = address.value().bytes();
1443 return DynamicByteBuffer(StaticByteBuffer(
1444 hci_spec::kCommandCompleteEventCode,
1445 0x0A, // parameter_total_size (10 bytes)
1446 0xF0, // Num_HCI_Command_Packets allowed to be sent to controller (240)
1447 LowerBits(hci_spec::kUserPasskeyRequestReply), // Command_Opcode
1448 UpperBits(hci_spec::kUserPasskeyRequestReply), // Command_Opcode
1449 pw::bluetooth::emboss::StatusCode::SUCCESS, // Status
1450 // peer BD_ADDR (6 bytes)
1451 addr[0],
1452 addr[1],
1453 addr[2],
1454 addr[3],
1455 addr[4],
1456 addr[5]));
1457 }
1458
WriteAutomaticFlushTimeoutPacket(hci_spec::ConnectionHandle conn,uint16_t flush_timeout)1459 DynamicByteBuffer WriteAutomaticFlushTimeoutPacket(
1460 hci_spec::ConnectionHandle conn, uint16_t flush_timeout) {
1461 return DynamicByteBuffer(StaticByteBuffer(
1462 LowerBits(hci_spec::kWriteAutomaticFlushTimeout),
1463 UpperBits(hci_spec::kWriteAutomaticFlushTimeout),
1464 0x04, // parameter_total_size (4 bytes)
1465 LowerBits(conn), // Connection_Handle
1466 UpperBits(conn), // Connection_Handle
1467 LowerBits(flush_timeout), // Flush_Timeout
1468 UpperBits(flush_timeout) // Flush_Timeout
1469 ));
1470 }
1471
WriteInquiryScanActivity(uint16_t scan_interval,uint16_t scan_window)1472 DynamicByteBuffer WriteInquiryScanActivity(uint16_t scan_interval,
1473 uint16_t scan_window) {
1474 return DynamicByteBuffer(StaticByteBuffer(
1475 LowerBits(hci_spec::kWriteInquiryScanActivity),
1476 UpperBits(hci_spec::kWriteInquiryScanActivity),
1477 0x04, // parameter_total_size (4 bytes)
1478 LowerBits(scan_interval), // Inquiry_Scan_Interval
1479 UpperBits(scan_interval), // Inquiry_Scan_Interval
1480 LowerBits(scan_window), // Inquiry_Scan_Window
1481 UpperBits(scan_window) // Inquiry_Scan_Window
1482 ));
1483 }
1484
WritePageScanActivityPacket(uint16_t scan_interval,uint16_t scan_window)1485 DynamicByteBuffer WritePageScanActivityPacket(uint16_t scan_interval,
1486 uint16_t scan_window) {
1487 return DynamicByteBuffer(StaticByteBuffer(
1488 LowerBits(hci_spec::kWritePageScanActivity),
1489 UpperBits(hci_spec::kWritePageScanActivity),
1490 0x04, // parameter_total_size (4 bytes)
1491 LowerBits(scan_interval), // Page_Scan_Interval
1492 UpperBits(scan_interval), // Page_Scan_Interval
1493 LowerBits(scan_window), // Page_Scan_Window
1494 UpperBits(scan_window) // Page_Scan_Window
1495 ));
1496 }
1497
WritePageScanTypePacket(uint8_t scan_type)1498 DynamicByteBuffer WritePageScanTypePacket(uint8_t scan_type) {
1499 return DynamicByteBuffer(StaticByteBuffer(
1500 LowerBits(hci_spec::kWritePageScanType),
1501 UpperBits(hci_spec::kWritePageScanType),
1502 0x01, // parameter_total_size (1 byte)
1503 scan_type // Page_Scan_Type
1504 ));
1505 }
1506
WritePageScanTypeResponse()1507 DynamicByteBuffer WritePageScanTypeResponse() {
1508 return CommandCompletePacket(hci_spec::kWritePageScanType,
1509 pw::bluetooth::emboss::StatusCode::SUCCESS);
1510 }
1511
WritePageTimeoutPacket(uint16_t page_timeout)1512 DynamicByteBuffer WritePageTimeoutPacket(uint16_t page_timeout) {
1513 return DynamicByteBuffer(StaticByteBuffer(
1514 LowerBits(hci_spec::kWritePageTimeout),
1515 UpperBits(hci_spec::kWritePageTimeout),
1516 0x02, // parameter_total_size (2 bytes)
1517 LowerBits(page_timeout), // Page_Timeout
1518 UpperBits(page_timeout) // Page_Timeout
1519 ));
1520 }
1521
WritePinTypePacket(uint8_t pin_type)1522 DynamicByteBuffer WritePinTypePacket(uint8_t pin_type) {
1523 return DynamicByteBuffer(StaticByteBuffer(
1524 LowerBits(hci_spec::kWritePinType),
1525 UpperBits(hci_spec::kWritePinType),
1526 0x01, // parameter_total_size (1 byte)
1527 pin_type // PIN_Type
1528 ));
1529 }
1530
WriteScanEnable(uint8_t scan_enable)1531 DynamicByteBuffer WriteScanEnable(uint8_t scan_enable) {
1532 return DynamicByteBuffer(StaticByteBuffer(
1533 LowerBits(hci_spec::kWriteScanEnable),
1534 UpperBits(hci_spec::kWriteScanEnable),
1535 0x01, // parameter_total_size (1 byte)
1536 scan_enable // Scan_Enable
1537 ));
1538 }
1539
1540 } // namespace bt::testing
1541