1 /*
2 * Copyright (C) 2014 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "hsp_hs.c"
39
40 // *****************************************************************************
41 //
42 // HSP Headset
43 //
44 // *****************************************************************************
45
46 #include "btstack_config.h"
47
48 #include <stdint.h>
49 #include <stdio.h>
50 #include <string.h>
51
52 #include "bluetooth_sdp.h"
53 #include "btstack_debug.h"
54 #include "btstack_event.h"
55 #include "btstack_memory.h"
56 #include "btstack_run_loop.h"
57 #include "classic/core.h"
58 #include "classic/sdp_server.h"
59 #include "classic/sdp_client_rfcomm.h"
60 #include "classic/sdp_util.h"
61 #include "classic/sdp_client.h"
62 #include "hci.h"
63 #include "hci_cmd.h"
64 #include "hci_dump.h"
65 #include "hsp_hs.h"
66 #include "l2cap.h"
67
68 #define HSP_AG_OK "OK"
69 #define HSP_AG_ERROR "ERROR"
70 #define HSP_AG_RING "RING"
71 #define HSP_MICROPHONE_GAIN "+VGM="
72 #define HSP_SPEAKER_GAIN "+VGS="
73
74 #define HSP_HS_AT_CKPD "AT+CKPD=200\r\n"
75 #define HSP_HS_MICROPHONE_GAIN "AT+VGM"
76 #define HSP_HS_SPEAKER_GAIN "AT+VGS"
77
78 static const char hsp_hs_default_service_name[] = "Headset";
79
80 typedef enum {
81 HSP_IDLE,
82 HSP_W2_SEND_SDP_QUERY,
83 HSP_W4_SDP_QUERY_COMPLETE,
84 HSP_W4_RFCOMM_CONNECTED,
85
86 HSP_RFCOMM_CONNECTION_ESTABLISHED,
87
88 HSP_W2_CONNECT_SCO,
89 HSP_W4_SCO_CONNECTED,
90
91 HSP_AUDIO_CONNECTION_ESTABLISHED,
92
93 HSP_W2_DISCONNECT_SCO,
94 HSP_W4_SCO_DISCONNECTED,
95
96 HSP_W2_DISCONNECT_RFCOMM,
97 HSP_W4_RFCOMM_DISCONNECTED,
98 HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN
99 } hsp_state_t;
100
101 // higher-layer callbacks
102 static btstack_packet_handler_t hsp_hs_callback;
103
104 static bd_addr_t hsp_hs_remote;
105 static uint8_t hsp_hs_rfcomm_channel_nr;
106 static uint16_t hsp_hs_rfcomm_cid;
107 static uint16_t hsp_hs_rfcomm_mtu;
108
109 static hci_con_handle_t hsp_hs_sco_handle;
110 static hci_con_handle_t hsp_hs_rfcomm_handle;
111
112 static hsp_state_t hsp_state;
113
114 static int hsp_hs_microphone_gain;
115 static int hsp_hs_speaker_gain;
116
117 static uint8_t hsp_hs_send_button_press_triggered;
118 static uint8_t hsp_hs_wait_ok;
119 static uint8_t hsp_hs_accept_sco_connection;
120
121 static uint8_t hsp_hs_support_custom_indications;
122 static uint8_t hsp_hs_establish_audio_connection_triggered;
123 static uint8_t hsp_hs_release_audio_connection_triggered;
124
125 static uint16_t hsp_hs_sco_packet_types;
126
127 static btstack_packet_callback_registration_t hsp_hs_hci_event_callback_registration;
128 static btstack_context_callback_registration_t hsp_hs_handle_sdp_client_query_request;
129
130 #ifdef ENABLE_RTK_PCM_WBS
131 static bool hsp_hs_rtk_send_sco_config;
132 #endif
133
134 static void hsp_run(void);
135 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
136 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
137
hsp_hs_register_packet_handler(btstack_packet_handler_t callback)138 void hsp_hs_register_packet_handler(btstack_packet_handler_t callback){
139 btstack_assert(callback);
140 hsp_hs_callback = callback;
141 }
142
emit_event(uint8_t event_subtype)143 static void emit_event(uint8_t event_subtype){
144 if (!hsp_hs_callback) return;
145 uint8_t event[5];
146 event[0] = HCI_EVENT_HSP_META;
147 event[1] = sizeof(event) - 2;
148 event[2] = event_subtype;
149 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
150 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
151 }
152
emit_event_with_value(uint8_t event_subtype,uint8_t value)153 static void emit_event_with_value(uint8_t event_subtype, uint8_t value){
154 if (!hsp_hs_callback) return;
155 uint8_t event[6];
156 event[0] = HCI_EVENT_HSP_META;
157 event[1] = sizeof(event) - 2;
158 event[2] = event_subtype;
159 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
160 event[5] = value;
161 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
162 }
163
emit_event_rfcomm_connected(uint8_t status)164 static void emit_event_rfcomm_connected(uint8_t status){
165 if (!hsp_hs_callback) return;
166 uint8_t event[12];
167 event[0] = HCI_EVENT_HSP_META;
168 event[1] = sizeof(event) - 2;
169 event[2] = HSP_SUBEVENT_RFCOMM_CONNECTION_COMPLETE;
170 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
171 event[5] = status;
172 reverse_bd_addr(hsp_hs_remote, &event[6]);
173 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
174 }
175
emit_event_audio_connected(uint8_t status,uint16_t sco_handle)176 static void emit_event_audio_connected(uint8_t status, uint16_t sco_handle){
177 if (!hsp_hs_callback) return;
178 uint8_t event[8];
179 event[0] = HCI_EVENT_HSP_META;
180 event[1] = sizeof(event) - 2;
181 event[2] = HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE;
182 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
183 event[5] = status;
184 little_endian_store_16(event, 6, sco_handle);
185 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
186 }
187
emit_event_audio_disconnected(uint16_t sco_handle)188 static void emit_event_audio_disconnected(uint16_t sco_handle){
189 if (!hsp_hs_callback) return;
190 uint8_t event[7];
191 event[0] = HCI_EVENT_HSP_META;
192 event[1] = sizeof(event) - 2;
193 event[2] = HSP_SUBEVENT_AUDIO_DISCONNECTION_COMPLETE;
194 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
195 little_endian_store_16(event, 5, sco_handle);
196 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
197 }
198
199
200 // remote audio volume control
201 // AG +VGM=13 [0..15] ; HS AT+VGM=6 | AG OK
202
hsp_hs_send_str_over_rfcomm(uint16_t cid,const char * command)203 static int hsp_hs_send_str_over_rfcomm(uint16_t cid, const char * command){
204 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) return 1;
205 int err = rfcomm_send(cid, (uint8_t*) command, (uint16_t) strlen(command));
206 if (err){
207 log_info("rfcomm_send_internal -> error 0X%02x", err);
208 }
209 return err;
210 }
211
hsp_hs_enable_custom_indications(int enable)212 void hsp_hs_enable_custom_indications(int enable){
213 hsp_hs_support_custom_indications = enable;
214 }
215
hsp_hs_send_result(const char * result)216 int hsp_hs_send_result(const char * result){
217 if (!hsp_hs_support_custom_indications) return 1;
218 return hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, result);
219 }
220
221
hsp_hs_create_sdp_record(uint8_t * service,uint32_t service_record_handle,int rfcomm_channel_nr,const char * name,uint8_t have_remote_audio_control)222 void hsp_hs_create_sdp_record(uint8_t * service, uint32_t service_record_handle, int rfcomm_channel_nr, const char * name, uint8_t have_remote_audio_control){
223 uint8_t* attribute;
224 de_create_sequence(service);
225
226 // 0x0000 "Service Record Handle"
227 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE);
228 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle);
229
230 // 0x0001 "Service Class ID List"
231 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
232 attribute = de_push_sequence(service);
233 {
234 // see Bluetooth Erratum #3507
235 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HEADSET); // 0x1108
236 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HEADSET_HS); // 0x1131
237 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO); // 0x1203
238 }
239 de_pop_sequence(service, attribute);
240
241 // 0x0004 "Protocol Descriptor List"
242 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
243 attribute = de_push_sequence(service);
244 {
245 uint8_t* l2cpProtocol = de_push_sequence(attribute);
246 {
247 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
248 }
249 de_pop_sequence(attribute, l2cpProtocol);
250
251 uint8_t* rfcomm = de_push_sequence(attribute);
252 {
253 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service
254 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel
255 }
256 de_pop_sequence(attribute, rfcomm);
257 }
258 de_pop_sequence(service, attribute);
259
260 // 0x0005 "Public Browse Group"
261 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group
262 attribute = de_push_sequence(service);
263 {
264 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT);
265 }
266 de_pop_sequence(service, attribute);
267
268 // 0x0009 "Bluetooth Profile Descriptor List"
269 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
270 attribute = de_push_sequence(service);
271 {
272 uint8_t *hsp_profile = de_push_sequence(attribute);
273 {
274 de_add_number(hsp_profile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HEADSET);
275 de_add_number(hsp_profile, DE_UINT, DE_SIZE_16, 0x0102); // Verision 1.2
276 }
277 de_pop_sequence(attribute, hsp_profile);
278 }
279 de_pop_sequence(service, attribute);
280
281 // 0x0100 "Service Name"
282 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100);
283 if (name){
284 de_add_data(service, DE_STRING, (uint16_t) strlen(name), (uint8_t *) name);
285 } else {
286 de_add_data(service, DE_STRING, (uint16_t) strlen(hsp_hs_default_service_name), (uint8_t *) hsp_hs_default_service_name);
287 }
288
289 // Remote audio volume control
290 de_add_number(service, DE_UINT, DE_SIZE_16, 0x030C);
291 de_add_number(service, DE_BOOL, DE_SIZE_8, have_remote_audio_control);
292 }
293
hsp_hs_reset_state(void)294 static void hsp_hs_reset_state(void){
295 hsp_state = HSP_IDLE;
296 hsp_hs_microphone_gain = -1;
297 hsp_hs_speaker_gain = -1;
298 hsp_hs_rfcomm_cid = 0;
299 hsp_hs_rfcomm_channel_nr = 0;
300 hsp_hs_rfcomm_handle = HCI_CON_HANDLE_INVALID;
301 hsp_hs_sco_handle = HCI_CON_HANDLE_INVALID;
302
303 hsp_hs_send_button_press_triggered = 0;
304 hsp_hs_wait_ok = 0;
305 hsp_hs_support_custom_indications = 0;
306
307 hsp_hs_accept_sco_connection = 0;
308 hsp_hs_establish_audio_connection_triggered = 0;
309 hsp_hs_release_audio_connection_triggered = 0;
310 }
311
hsp_hs_init(uint8_t rfcomm_channel_nr)312 void hsp_hs_init(uint8_t rfcomm_channel_nr){
313 // register for HCI events
314 hsp_hs_hci_event_callback_registration.callback = &packet_handler;
315 hci_add_event_handler(&hsp_hs_hci_event_callback_registration);
316
317 rfcomm_register_service(packet_handler, rfcomm_channel_nr, 0xffff); // reserved channel, mtu limited by l2cap
318
319 hsp_hs_sco_packet_types = SCO_PACKET_TYPES_ALL;
320 hsp_hs_reset_state();
321 }
322
hsp_hs_deinit(void)323 void hsp_hs_deinit(void){
324 hsp_hs_reset_state();
325 hsp_hs_callback = NULL;
326 (void)memset(hsp_hs_remote, 0, 6);
327 (void)memset(&hsp_hs_hci_event_callback_registration, 0, sizeof(btstack_packet_callback_registration_t));
328 (void)memset(&hsp_hs_handle_sdp_client_query_request, 0, sizeof(btstack_context_callback_registration_t));
329 }
330
hsp_hs_handle_start_sdp_client_query(void * context)331 static void hsp_hs_handle_start_sdp_client_query(void * context){
332 UNUSED(context);
333 if (hsp_state != HSP_W2_SEND_SDP_QUERY) return;
334
335 hsp_state = HSP_W4_SDP_QUERY_COMPLETE;
336 log_info("Start SDP query %s, 0x%02x", bd_addr_to_str(hsp_hs_remote), BLUETOOTH_SERVICE_CLASS_HEADSET_AUDIO_GATEWAY_AG);
337 sdp_client_query_rfcomm_channel_and_name_for_service_class_uuid(&handle_query_rfcomm_event, hsp_hs_remote, BLUETOOTH_SERVICE_CLASS_HEADSET_AUDIO_GATEWAY_AG);
338 }
339
hsp_hs_connect(bd_addr_t bd_addr)340 void hsp_hs_connect(bd_addr_t bd_addr){
341 if (hsp_state != HSP_IDLE) return;
342
343 (void)memcpy(hsp_hs_remote, bd_addr, 6);
344 hsp_state = HSP_W2_SEND_SDP_QUERY;
345 hsp_hs_handle_sdp_client_query_request.callback = &hsp_hs_handle_start_sdp_client_query;
346 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback
347 (void) sdp_client_register_query_callback(&hsp_hs_handle_sdp_client_query_request);
348 }
349
hsp_hs_disconnect(void)350 void hsp_hs_disconnect(void){
351 hsp_hs_release_audio_connection();
352
353 if (hsp_state < HSP_W4_RFCOMM_CONNECTED){
354 hsp_state = HSP_IDLE;
355 return;
356 }
357
358 if (hsp_state == HSP_W4_RFCOMM_CONNECTED){
359 hsp_state = HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN;
360 return;
361 }
362
363 hsp_hs_establish_audio_connection_triggered = 0;
364 rfcomm_disconnect(hsp_hs_rfcomm_cid);
365 }
366
367
hsp_hs_establish_audio_connection(void)368 void hsp_hs_establish_audio_connection(void){
369 switch (hsp_state){
370 case HSP_RFCOMM_CONNECTION_ESTABLISHED:
371 hsp_hs_establish_audio_connection_triggered = 1;
372 hsp_state = HSP_W4_SCO_CONNECTED;
373 break;
374 case HSP_W4_RFCOMM_CONNECTED:
375 hsp_state = HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN;
376 break;
377 default:
378 break;
379 }
380 hsp_run();
381 }
382
hsp_hs_release_audio_connection(void)383 void hsp_hs_release_audio_connection(void){
384 if (hsp_state >= HSP_W2_DISCONNECT_SCO) return;
385 if (hsp_state < HSP_AUDIO_CONNECTION_ESTABLISHED) return;
386 hsp_hs_release_audio_connection_triggered = 1;
387 hsp_run();
388 }
389
hsp_hs_set_microphone_gain(uint8_t gain)390 void hsp_hs_set_microphone_gain(uint8_t gain){
391 if (gain >15) {
392 log_info("Gain must be in interval [0..15], it is given %d", gain);
393 return;
394 }
395 hsp_hs_microphone_gain = gain;
396 hsp_run();
397 }
398
399 // AG +VGS=5 [0..15] ; HS AT+VGM=6 | AG OK
hsp_hs_set_speaker_gain(uint8_t gain)400 void hsp_hs_set_speaker_gain(uint8_t gain){
401 if (gain >15) {
402 log_info("Gain must be in interval [0..15], it is given %d", gain);
403 return;
404 }
405 hsp_hs_speaker_gain = gain;
406 hsp_run();
407 }
408
hsp_run_handle_state(void)409 static void hsp_run_handle_state(void){
410 switch (hsp_state){
411 case HSP_AUDIO_CONNECTION_ESTABLISHED:
412 case HSP_RFCOMM_CONNECTION_ESTABLISHED:
413
414 if (hsp_hs_microphone_gain >= 0){
415 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) {
416 rfcomm_request_can_send_now_event(hsp_hs_rfcomm_cid);
417 return;
418 }
419 char buffer[20];
420 btstack_snprintf_assert_complete(buffer, sizeof(buffer), "%s=%d\r",
421 HSP_HS_MICROPHONE_GAIN, hsp_hs_microphone_gain);
422 hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, buffer);
423 hsp_hs_microphone_gain = -1;
424 break;
425 }
426
427 if (hsp_hs_speaker_gain >= 0){
428 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) {
429 rfcomm_request_can_send_now_event(hsp_hs_rfcomm_cid);
430 return;
431 }
432 char buffer[20];
433 btstack_snprintf_assert_complete(buffer, sizeof(buffer), "%s=%d\r",
434 HSP_HS_SPEAKER_GAIN, hsp_hs_speaker_gain);
435 hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, buffer);
436 hsp_hs_speaker_gain = -1;
437 break;
438 }
439 break;
440 case HSP_W4_RFCOMM_DISCONNECTED:
441 rfcomm_disconnect(hsp_hs_rfcomm_cid);
442 break;
443 default:
444 break;
445 }
446 }
447
hsp_run(void)448 static void hsp_run(void){
449
450 if (hsp_hs_wait_ok) return;
451
452 if (hsp_hs_accept_sco_connection && hci_can_send_command_packet_now()){
453
454 bool eSCO = hsp_hs_accept_sco_connection == 2;
455 hsp_hs_accept_sco_connection = 0;
456
457 log_info("HSP: sending hci_accept_connection_request.");
458
459 // pick packet types based on SCO link type (SCO vs. eSCO)
460 uint16_t packet_types;
461 if (eSCO && hci_extended_sco_link_supported() && hci_remote_esco_supported(hsp_hs_rfcomm_handle)){
462 packet_types = SCO_PACKET_TYPES_EV3 | SCO_PACKET_TYPES_2EV3;
463 } else {
464 packet_types = SCO_PACKET_TYPES_HV3 | SCO_PACKET_TYPES_HV2 | SCO_PACKET_TYPES_HV1;
465 }
466
467 // packet type override
468 packet_types &= hsp_hs_sco_packet_types;
469
470 // bits 6-9 are 'don't use'
471 packet_types ^= 0x03c0;
472
473 uint16_t sco_voice_setting = hci_get_sco_voice_setting();
474
475 log_info("HFP: sending hci_accept_connection_request, sco_voice_setting %02x", sco_voice_setting);
476 hci_send_cmd(&hci_accept_synchronous_connection, hsp_hs_remote, 8000, 8000, 0xffff, sco_voice_setting, 0xff, packet_types);
477 return;
478 }
479
480 if (hsp_hs_release_audio_connection_triggered){
481 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) {
482 rfcomm_request_can_send_now_event(hsp_hs_rfcomm_cid);
483 return;
484 }
485 hsp_hs_release_audio_connection_triggered = 0;
486 hsp_hs_wait_ok = 1;
487 hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, HSP_HS_AT_CKPD);
488 return;
489 }
490
491 if (hsp_hs_establish_audio_connection_triggered){
492 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) {
493 rfcomm_request_can_send_now_event(hsp_hs_rfcomm_cid);
494 return;
495 }
496 hsp_hs_establish_audio_connection_triggered = 0;
497 hsp_hs_wait_ok = 1;
498 hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, HSP_HS_AT_CKPD);
499 return;
500 }
501
502 if (hsp_hs_send_button_press_triggered){
503 if (!rfcomm_can_send_packet_now(hsp_hs_rfcomm_cid)) {
504 rfcomm_request_can_send_now_event(hsp_hs_rfcomm_cid);
505 return;
506 }
507 hsp_hs_send_button_press_triggered = 0;
508 hsp_hs_wait_ok = 1;
509 hsp_hs_send_str_over_rfcomm(hsp_hs_rfcomm_cid, HSP_HS_AT_CKPD);
510 return;
511 }
512
513 #ifdef ENABLE_RTK_PCM_WBS
514 if (hsp_hs_rtk_send_sco_config){
515 hsp_hs_rtk_send_sco_config = false;
516 log_info("RTK SCO: 16k + CVSD");
517 hci_send_cmd(&hci_rtk_configure_sco_routing, 0x81, 0x90, 0x00, 0x00, 0x1a, 0x0c, 0x0c, 0x00, 0x01);
518 return;
519 }
520 #endif
521
522 hsp_run_handle_state();
523 }
524
525
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)526 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
527 UNUSED(channel); // ok: no channel for HCI_EVENT_PACKET and only single active RFCOMM channel
528 if (packet_type == RFCOMM_DATA_PACKET){
529 // skip over leading newline
530 while ((size > 0) && ((packet[0] == '\n') || (packet[0] == '\r'))){
531 size--;
532 packet++;
533 }
534 if (strncmp((char *)packet, HSP_AG_RING, strlen(HSP_AG_RING)) == 0){
535 emit_event(HSP_SUBEVENT_RING);
536 } else if (strncmp((char *)packet, HSP_AG_OK, strlen(HSP_AG_OK)) == 0){
537 hsp_hs_wait_ok = 0;
538 } else if (strncmp((char *)packet, HSP_MICROPHONE_GAIN, strlen(HSP_MICROPHONE_GAIN)) == 0){
539 uint8_t gain = (uint8_t)btstack_atoi((char*)&packet[strlen(HSP_MICROPHONE_GAIN)]);
540 emit_event_with_value(HSP_SUBEVENT_MICROPHONE_GAIN_CHANGED, gain);
541
542 } else if (strncmp((char *)packet, HSP_SPEAKER_GAIN, strlen(HSP_SPEAKER_GAIN)) == 0){
543 uint8_t gain = (uint8_t)btstack_atoi((char*)&packet[strlen(HSP_SPEAKER_GAIN)]);
544 emit_event_with_value(HSP_SUBEVENT_SPEAKER_GAIN_CHANGED, gain);
545 } else {
546 if (!hsp_hs_callback) return;
547 // strip trailing newline
548 while ((size > 0) && ((packet[size-1] == '\n') || (packet[size-1] == '\r'))){
549 size--;
550 }
551 if ((size + 4) > 255) return;
552 // add trailing \0
553 packet[size] = 0;
554 // re-use incoming buffer to avoid reserving buffers/memcpy - ugly but efficient
555 uint8_t * event = packet - 6;
556 event[0] = HCI_EVENT_HSP_META;
557 event[1] = (uint8_t) (size + 4);
558 event[2] = HSP_SUBEVENT_AG_INDICATION;
559 little_endian_store_16(event, 3, hsp_hs_rfcomm_handle);
560 event[5] = (uint8_t) size;
561 (*hsp_hs_callback)(HCI_EVENT_PACKET, 0, event, size+6);
562 }
563 hsp_run();
564 return;
565 }
566
567 if (packet_type != HCI_EVENT_PACKET) return;
568
569 uint8_t event = hci_event_packet_get_type(packet);
570 bd_addr_t event_addr;
571 uint16_t handle;
572 uint8_t status;
573
574 switch (event) {
575 case HCI_EVENT_CONNECTION_REQUEST:
576 switch(hci_event_connection_request_get_link_type(packet)){
577 case 0: // SCO
578 case 2: // eSCO
579 hci_event_connection_request_get_bd_addr(packet, event_addr);
580 if (bd_addr_cmp(event_addr, hsp_hs_remote) == 0){
581 if (hci_event_connection_request_get_link_type(packet) == 2){
582 hsp_hs_accept_sco_connection = 2;
583 } else {
584 hsp_hs_accept_sco_connection = 1;
585 }
586 log_info("hs_accept_sco_connection %u", hsp_hs_accept_sco_connection);
587 }
588 break;
589 default:
590 break;
591 }
592 break;
593
594 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{
595 if (hsp_state < HSP_RFCOMM_CONNECTION_ESTABLISHED) return;
596 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr);
597 status = hci_event_synchronous_connection_complete_get_status(packet);
598 hsp_hs_sco_handle = hci_event_synchronous_connection_complete_get_handle(packet);
599 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet);
600 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots
601 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet); // measured in slots
602 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes
603 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes
604
605 if (status != 0){
606 log_error("(e)SCO Connection failed, status %u", status);
607 emit_event_audio_connected(status, hsp_hs_sco_handle);
608 hsp_state = HSP_RFCOMM_CONNECTION_ESTABLISHED ;
609 break;
610 }
611
612 switch (link_type){
613 case 0x00:
614 log_info("SCO Connection established.");
615 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval);
616 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval);
617 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length);
618 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length);
619 break;
620 case 0x02:
621 log_info("eSCO Connection established.");
622 break;
623 default:
624 log_error("(e)SCO reserved link_type 0x%2x", link_type);
625 break;
626 }
627 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, "
628 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)", hsp_hs_sco_handle,
629 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length,
630 hci_event_synchronous_connection_complete_get_air_mode(packet));
631
632 hsp_state = HSP_AUDIO_CONNECTION_ESTABLISHED;
633 emit_event_audio_connected(status, hsp_hs_sco_handle);
634 break;
635 }
636
637 case RFCOMM_EVENT_INCOMING_CONNECTION:
638 if (hsp_state != HSP_IDLE) return;
639 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr);
640 hsp_hs_rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet);
641 log_info("RFCOMM channel %u requested for %s", rfcomm_event_incoming_connection_get_server_channel(packet), bd_addr_to_str(event_addr));
642 hsp_state = HSP_W4_RFCOMM_CONNECTED;
643 rfcomm_accept_connection(hsp_hs_rfcomm_cid);
644 break;
645
646 case RFCOMM_EVENT_CHANNEL_OPENED:
647 if (hsp_state != HSP_W4_RFCOMM_CONNECTED) return;
648 status = rfcomm_event_channel_opened_get_status(packet);
649 if (status != ERROR_CODE_SUCCESS) {
650 log_info("RFCOMM channel open failed, status %u", status);
651 hsp_state = HSP_IDLE;
652 hsp_hs_reset_state();
653 } else {
654 rfcomm_event_channel_opened_get_bd_addr(packet, hsp_hs_remote);
655 hsp_hs_rfcomm_handle = rfcomm_event_channel_opened_get_con_handle(packet);
656 hsp_hs_rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet);
657 rfcomm_event_channel_opened_get_bd_addr(packet, hsp_hs_remote);
658 hsp_hs_rfcomm_mtu = rfcomm_event_channel_opened_get_max_frame_size(packet);
659 log_info("RFCOMM channel open succeeded. New RFCOMM Channel ID %u, max frame size %u, handle %02x", hsp_hs_rfcomm_cid, hsp_hs_rfcomm_mtu, hsp_hs_rfcomm_handle);
660 hsp_state = HSP_RFCOMM_CONNECTION_ESTABLISHED;
661 #ifdef ENABLE_RTK_PCM_WBS
662 hsp_hs_rtk_send_sco_config = true;
663 #endif
664 }
665 emit_event_rfcomm_connected(status);
666 break;
667
668 case RFCOMM_EVENT_CAN_SEND_NOW:
669 hsp_run();
670 break;
671
672 case HCI_EVENT_DISCONNECTION_COMPLETE:
673 handle = hci_event_disconnection_complete_get_connection_handle(packet);
674 if (handle == hsp_hs_sco_handle){
675 hci_con_handle_t sco_handle = hsp_hs_sco_handle;
676 hsp_hs_sco_handle = HCI_CON_HANDLE_INVALID;
677 hsp_state = HSP_RFCOMM_CONNECTION_ESTABLISHED;
678 emit_event_audio_disconnected(sco_handle);
679 break;
680 }
681 break;
682
683 case RFCOMM_EVENT_CHANNEL_CLOSED:
684 hsp_state = HSP_IDLE;
685 hsp_hs_reset_state();
686 emit_event(HSP_SUBEVENT_RFCOMM_DISCONNECTION_COMPLETE);
687 break;
688
689 default:
690 break;
691 }
692
693 hsp_run();
694 }
695
handle_query_rfcomm_event(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)696 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
697 UNUSED(packet_type); // ok: handling own sdp events
698 UNUSED(channel); // ok: no channel
699 UNUSED(size); // ok: handling own sdp events
700
701 switch (hci_event_packet_get_type(packet)){
702 case SDP_EVENT_QUERY_RFCOMM_SERVICE:
703 hsp_hs_rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet);
704 log_info("** Service name: '%s', RFCOMM port %u", sdp_event_query_rfcomm_service_get_name(packet), hsp_hs_rfcomm_channel_nr);
705 break;
706 case SDP_EVENT_QUERY_COMPLETE:
707 if (hsp_hs_rfcomm_channel_nr > 0){
708 hsp_state = HSP_W4_RFCOMM_CONNECTED;
709 log_info("HSP: SDP_QUERY_COMPLETE. RFCOMM create channel, addr %s, rfcomm channel nr %d", bd_addr_to_str(hsp_hs_remote), hsp_hs_rfcomm_channel_nr);
710 rfcomm_create_channel(packet_handler, hsp_hs_remote, hsp_hs_rfcomm_channel_nr, NULL);
711 break;
712 }
713 hsp_hs_reset_state();
714 log_info("Service not found, status %u.", sdp_event_query_complete_get_status(packet));
715 if (sdp_event_query_complete_get_status(packet)){
716 emit_event_with_value(HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE,
717 sdp_event_query_complete_get_status(packet));
718 } else {
719 emit_event_with_value(HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE, SDP_SERVICE_NOT_FOUND);
720 }
721 break;
722 default:
723 break;
724 }
725 }
726
hsp_hs_send_button_press(void)727 void hsp_hs_send_button_press(void){
728 if ((hsp_state < HSP_RFCOMM_CONNECTION_ESTABLISHED) || (hsp_state >= HSP_W4_RFCOMM_DISCONNECTED)) return;
729 hsp_hs_send_button_press_triggered = 1;
730 hsp_run();
731 }
732
hsp_hs_set_sco_packet_types(uint16_t packet_types)733 void hsp_hs_set_sco_packet_types(uint16_t packet_types){
734 hsp_hs_sco_packet_types = packet_types;
735 }
736