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_ag.c"
39
40 // *****************************************************************************
41 //
42 // HSP Audio Gateway
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_ag.h"
66 #include "l2cap.h"
67
68 #define HSP_HS_BUTTON_PRESS "AT+CKPD=200"
69 #define HSP_HS_AT_CKPD "AT+CKPD\r\n"
70 #define HSP_AG_OK "\r\nOK\r\n"
71 #define HSP_AG_ERROR "\r\nERROR\r\n"
72 #define HSP_AG_RING "\r\nRING\r\n"
73 #define HSP_MICROPHONE_GAIN "+VGM"
74 #define HSP_SPEAKER_GAIN "+VGS"
75
76 #define HSP_HS_MICROPHONE_GAIN "AT+VGM="
77 #define HSP_HS_SPEAKER_GAIN "AT+VGS="
78
79 static const char hsp_ag_default_service_name[] = "Audio Gateway";
80
81 typedef enum {
82 HSP_IDLE,
83 HSP_W2_SEND_SDP_QUERY,
84 HSP_W4_SDP_QUERY_COMPLETE,
85 HSP_W4_RFCOMM_CONNECTED,
86
87 HSP_RFCOMM_CONNECTION_ESTABLISHED,
88
89 HSP_W4_RING_ANSWER,
90 HSP_W4_USER_ACTION,
91 HSP_W2_CONNECT_SCO,
92 HSP_W4_SCO_CONNECTED,
93
94 HSP_AUDIO_CONNECTION_ESTABLISHED,
95
96 HSP_W2_DISCONNECT_SCO,
97 HSP_W4_SCO_DISCONNECTED,
98
99 HSP_W2_DISCONNECT_RFCOMM,
100 HSP_W4_RFCOMM_DISCONNECTED,
101 HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN
102 } hsp_state_t;
103
104 // higher-layer callbacks
105 static btstack_packet_handler_t hsp_ag_callback;
106
107 static hsp_state_t hsp_ag_state;
108
109 static int hsp_ag_microphone_gain;
110 static int hsp_ag_speaker_gain;
111 static uint8_t hsp_ag_ring;
112 static uint8_t hsp_ag_send_ok;
113 static uint8_t hsp_ag_send_error;
114 static uint8_t hsp_ag_support_custom_commands;
115 static uint8_t hsp_ag_disconnect_rfcomm;
116 static uint8_t hsp_ag_release_audio_connection_triggered;
117 static uint16_t hsp_ag_sco_packet_types;
118
119 static bd_addr_t hsp_ag_remote;
120 static uint8_t hsp_ag_channel_nr;
121 static uint16_t hsp_ag_rfcomm_cid;
122 static uint16_t hsp_ag_mtu;
123
124 static hci_con_handle_t hsp_ag_sco_handle;
125 static hci_con_handle_t hsp_ag_rfcomm_handle;
126
127 static btstack_timer_source_t hsp_ag_timeout;
128
129 static btstack_packet_callback_registration_t hci_event_callback_registration;
130 static btstack_context_callback_registration_t hsp_ag_handle_sdp_client_query_request;
131
132 #ifdef ENABLE_RTK_PCM_WBS
133 static bool hsp_ag_rtk_send_sco_config;
134 #endif
135
136 static void hsp_run(void);
137 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
138 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
139
hsp_ag_register_packet_handler(btstack_packet_handler_t callback)140 void hsp_ag_register_packet_handler(btstack_packet_handler_t callback){
141 btstack_assert(callback != NULL);
142 hsp_ag_callback = callback;
143 }
144
emit_event(uint8_t event_subtype)145 static void emit_event(uint8_t event_subtype){
146 if (!hsp_ag_callback) return;
147 uint8_t event[5];
148 event[0] = HCI_EVENT_HSP_META;
149 event[1] = sizeof(event) - 2;
150 event[2] = event_subtype;
151 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
152 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
153 }
154
emit_event_with_value(uint8_t event_subtype,uint8_t value)155 static void emit_event_with_value(uint8_t event_subtype, uint8_t value){
156 if (!hsp_ag_callback) return;
157 uint8_t event[6];
158 event[0] = HCI_EVENT_HSP_META;
159 event[1] = sizeof(event) - 2;
160 event[2] = event_subtype;
161 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
162 event[5] = value;
163 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
164 }
165
emit_event_rfcomm_connected(uint8_t status)166 static void emit_event_rfcomm_connected(uint8_t status){
167 if (!hsp_ag_callback) return;
168 uint8_t event[12];
169 event[0] = HCI_EVENT_HSP_META;
170 event[1] = sizeof(event) - 2;
171 event[2] = HSP_SUBEVENT_RFCOMM_CONNECTION_COMPLETE;
172 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
173 event[5] = status;
174 reverse_bd_addr(hsp_ag_remote, &event[6]);
175 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
176 }
177
emit_event_audio_connected(uint8_t status,uint16_t sco_handle)178 static void emit_event_audio_connected(uint8_t status, uint16_t sco_handle){
179 if (!hsp_ag_callback) return;
180 uint8_t event[8];
181 event[0] = HCI_EVENT_HSP_META;
182 event[1] = sizeof(event) - 2;
183 event[2] = HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE;
184 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
185 event[5] = status;
186 little_endian_store_16(event, 6, sco_handle);
187 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
188 }
189
emit_event_audio_disconnected(uint16_t sco_handle)190 static void emit_event_audio_disconnected(uint16_t sco_handle){
191 if (!hsp_ag_callback) return;
192 uint8_t event[7];
193 event[0] = HCI_EVENT_HSP_META;
194 event[1] = sizeof(event) - 2;
195 event[2] = HSP_SUBEVENT_AUDIO_DISCONNECTION_COMPLETE;
196 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
197 little_endian_store_16(event, 5, sco_handle);
198 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
199 }
200
201
hsp_ag_create_sdp_record(uint8_t * service,uint32_t service_record_handle,int rfcomm_channel_nr,const char * name)202 void hsp_ag_create_sdp_record(uint8_t * service, uint32_t service_record_handle, int rfcomm_channel_nr, const char * name){
203 uint8_t* attribute;
204 de_create_sequence(service);
205
206 // 0x0000 "Service Record Handle"
207 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE);
208 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle);
209
210 // 0x0001 "Service Class ID List"
211 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
212 attribute = de_push_sequence(service);
213 {
214 // "UUID for PAN Service"
215 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HEADSET_AUDIO_GATEWAY_AG);
216 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO);
217 }
218 de_pop_sequence(service, attribute);
219
220 // 0x0004 "Protocol Descriptor List"
221 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
222 attribute = de_push_sequence(service);
223 {
224 uint8_t* l2cpProtocol = de_push_sequence(attribute);
225 {
226 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
227 }
228 de_pop_sequence(attribute, l2cpProtocol);
229
230 uint8_t* rfcomm = de_push_sequence(attribute);
231 {
232 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service
233 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel
234 }
235 de_pop_sequence(attribute, rfcomm);
236 }
237 de_pop_sequence(service, attribute);
238
239 // 0x0005 "Public Browse Group"
240 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group
241 attribute = de_push_sequence(service);
242 {
243 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT);
244 }
245 de_pop_sequence(service, attribute);
246
247 // 0x0009 "Bluetooth Profile Descriptor List"
248 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
249 attribute = de_push_sequence(service);
250 {
251 uint8_t *sppProfile = de_push_sequence(attribute);
252 {
253 de_add_number(sppProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HEADSET);
254 de_add_number(sppProfile, DE_UINT, DE_SIZE_16, 0x0102); // Verision 1.2
255 }
256 de_pop_sequence(attribute, sppProfile);
257 }
258 de_pop_sequence(service, attribute);
259
260 // 0x0100 "Service Name"
261 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100);
262 if (name){
263 de_add_data(service, DE_STRING, (uint16_t) strlen(name), (uint8_t *) name);
264 } else {
265 de_add_data(service, DE_STRING, (uint16_t) strlen(hsp_ag_default_service_name), (uint8_t *) hsp_ag_default_service_name);
266 }
267 }
268
hsp_ag_send_str_over_rfcomm(const uint16_t cid,const char * command)269 static int hsp_ag_send_str_over_rfcomm(const uint16_t cid, const char * command){
270 int err = rfcomm_send(cid, (uint8_t*) command, (uint16_t) strlen(command));
271 if (err){
272 log_error("rfcomm_send_internal -> error 0X%02x", err);
273 return err;
274 }
275 return err;
276 }
277
hsp_ag_enable_custom_commands(int enable)278 void hsp_ag_enable_custom_commands(int enable){
279 hsp_ag_support_custom_commands = enable;
280 }
281
hsp_ag_send_result(char * result)282 int hsp_ag_send_result(char * result){
283 if (!hsp_ag_support_custom_commands) return 1;
284 return hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, result);
285 }
286
hsp_ag_reset_state(void)287 static void hsp_ag_reset_state(void){
288 hsp_ag_state = HSP_IDLE;
289
290 hsp_ag_rfcomm_cid = 0;
291 hsp_ag_rfcomm_handle = HCI_CON_HANDLE_INVALID;
292 hsp_ag_channel_nr = 0;
293 hsp_ag_sco_handle = HCI_CON_HANDLE_INVALID;
294
295 hsp_ag_send_ok = 0;
296 hsp_ag_send_error = 0;
297 hsp_ag_ring = 0;
298
299 hsp_ag_support_custom_commands = 0;
300
301 hsp_ag_microphone_gain = -1;
302 hsp_ag_speaker_gain = -1;
303
304 hsp_ag_disconnect_rfcomm = 0;
305 hsp_ag_release_audio_connection_triggered = 0;
306 }
307
hsp_ag_init(uint8_t rfcomm_channel_nr)308 void hsp_ag_init(uint8_t rfcomm_channel_nr){
309 // register for HCI events
310 hci_event_callback_registration.callback = &packet_handler;
311 hci_add_event_handler(&hci_event_callback_registration);
312
313 rfcomm_register_service(packet_handler, rfcomm_channel_nr, 0xffff); // reserved channel, mtu limited by l2cap
314
315 hsp_ag_sco_packet_types = SCO_PACKET_TYPES_EV3 | SCO_PACKET_TYPES_2EV3 | SCO_PACKET_TYPES_HV3;
316 hsp_ag_reset_state();
317 }
318
hsp_ag_deinit(void)319 void hsp_ag_deinit(void){
320 hsp_ag_reset_state();
321 hsp_ag_callback = NULL;
322 (void)memset(hsp_ag_remote, 0, 6);
323 (void)memset(&hsp_ag_timeout, 0, sizeof(btstack_timer_source_t));
324 (void)memset(&hci_event_callback_registration, 0, sizeof(btstack_packet_callback_registration_t));
325 (void)memset(&hsp_ag_handle_sdp_client_query_request, 0, sizeof(btstack_context_callback_registration_t));
326 }
327
hsp_ag_handle_start_sdp_client_query(void * context)328 static void hsp_ag_handle_start_sdp_client_query(void * context){
329 UNUSED(context);
330 if (hsp_ag_state != HSP_W2_SEND_SDP_QUERY) return;
331
332 hsp_ag_state = HSP_W4_SDP_QUERY_COMPLETE;
333 log_info("Start SDP query %s, 0x%02x", bd_addr_to_str(hsp_ag_remote), BLUETOOTH_SERVICE_CLASS_HEADSET);
334 sdp_client_query_rfcomm_channel_and_name_for_service_class_uuid(&handle_query_rfcomm_event, hsp_ag_remote, BLUETOOTH_SERVICE_CLASS_HEADSET);
335 }
336
hsp_ag_connect(bd_addr_t bd_addr)337 void hsp_ag_connect(bd_addr_t bd_addr){
338 if (hsp_ag_state != HSP_IDLE) return;
339
340 (void)memcpy(hsp_ag_remote, bd_addr, 6);
341 hsp_ag_state = HSP_W2_SEND_SDP_QUERY;
342 hsp_ag_handle_sdp_client_query_request.callback = &hsp_ag_handle_start_sdp_client_query;
343 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback
344 (void) sdp_client_register_query_callback(&hsp_ag_handle_sdp_client_query_request);
345 }
346
hsp_ag_disconnect(void)347 void hsp_ag_disconnect(void){
348 hsp_ag_release_audio_connection();
349 if (hsp_ag_state < HSP_W4_RFCOMM_CONNECTED){
350 hsp_ag_state = HSP_IDLE;
351 return;
352 }
353
354 if (hsp_ag_state == HSP_W4_RFCOMM_CONNECTED){
355 hsp_ag_state = HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN;
356 return;
357 }
358 hsp_ag_disconnect_rfcomm = 1;
359 hsp_run();
360 }
361
hsp_ag_establish_audio_connection(void)362 void hsp_ag_establish_audio_connection(void){
363 switch (hsp_ag_state){
364 case HSP_RFCOMM_CONNECTION_ESTABLISHED:
365 hsp_ag_state = HSP_W2_CONNECT_SCO;
366 break;
367 case HSP_W4_RFCOMM_CONNECTED:
368 hsp_ag_state = HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN;
369 break;
370 default:
371 break;
372 }
373 hsp_run();
374 }
375
hsp_ag_release_audio_connection(void)376 void hsp_ag_release_audio_connection(void){
377 if (hsp_ag_state >= HSP_W2_DISCONNECT_SCO) return;
378 if (hsp_ag_state < HSP_AUDIO_CONNECTION_ESTABLISHED) return;
379
380 hsp_ag_release_audio_connection_triggered = 1;
381 hsp_run();
382 }
383
384
hsp_ag_set_microphone_gain(uint8_t gain)385 void hsp_ag_set_microphone_gain(uint8_t gain){
386 if (gain >15) {
387 log_error("Gain must be in interval [0..15], it is given %d", gain);
388 return;
389 }
390 hsp_ag_microphone_gain = gain;
391 hsp_run();
392 }
393
394 // AG +VGS=5 [0..15] ; HS AT+VGM=6 | AG OK
hsp_ag_set_speaker_gain(uint8_t gain)395 void hsp_ag_set_speaker_gain(uint8_t gain){
396 if (gain >15) {
397 log_error("Gain must be in interval [0..15], it is given %d", gain);
398 return;
399 }
400 hsp_ag_speaker_gain = gain;
401 hsp_run();
402 }
403
hsp_ringing_timeout_handler(btstack_timer_source_t * timer)404 static void hsp_ringing_timeout_handler(btstack_timer_source_t * timer){
405 hsp_ag_ring = 1;
406 btstack_run_loop_set_timer(timer, 2000); // 2 seconds timeout
407 btstack_run_loop_add_timer(timer);
408 hsp_run();
409 }
410
hsp_ringing_timer_start(void)411 static void hsp_ringing_timer_start(void){
412 btstack_run_loop_remove_timer(&hsp_ag_timeout);
413 btstack_run_loop_set_timer_handler(&hsp_ag_timeout, hsp_ringing_timeout_handler);
414 btstack_run_loop_set_timer(&hsp_ag_timeout, 2000); // 2 seconds timeout
415 btstack_run_loop_add_timer(&hsp_ag_timeout);
416 }
417
hsp_ringing_timer_stop(void)418 static void hsp_ringing_timer_stop(void){
419 btstack_run_loop_remove_timer(&hsp_ag_timeout);
420 }
421
hsp_ag_start_ringing(void)422 void hsp_ag_start_ringing(void){
423 hsp_ag_ring = 1;
424 if (hsp_ag_state == HSP_W2_CONNECT_SCO) {
425 hsp_ag_state = HSP_W4_RING_ANSWER;
426 }
427 hsp_ringing_timer_start();
428 }
429
hsp_ag_stop_ringing(void)430 void hsp_ag_stop_ringing(void){
431 hsp_ag_ring = 0;
432 if (hsp_ag_state == HSP_W4_RING_ANSWER){
433 hsp_ag_state = HSP_W2_CONNECT_SCO;
434 }
435 hsp_ringing_timer_stop();
436 }
437
hsp_run(void)438 static void hsp_run(void){
439 uint16_t packet_types;
440
441 if (hsp_ag_send_ok){
442 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
443 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
444 return;
445 }
446 hsp_ag_send_ok = 0;
447 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, HSP_AG_OK);
448 return;
449 }
450
451 if (hsp_ag_send_error){
452 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
453 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
454 return;
455 }
456 hsp_ag_send_error = 0;
457 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, HSP_AG_ERROR);
458 return;
459 }
460
461 if (hsp_ag_ring){
462 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
463 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
464 return;
465 }
466 hsp_ag_ring = 0;
467 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, HSP_AG_RING);
468 return;
469 }
470
471 if (hsp_ag_release_audio_connection_triggered){
472 hsp_ag_release_audio_connection_triggered = 0;
473 gap_disconnect(hsp_ag_sco_handle);
474 return;
475 }
476
477 if (hsp_ag_disconnect_rfcomm){
478 hsp_ag_disconnect_rfcomm = 0;
479 rfcomm_disconnect(hsp_ag_rfcomm_cid);
480 return;
481 }
482
483 #ifdef ENABLE_RTK_PCM_WBS
484 if (hsp_ag_rtk_send_sco_config){
485 hsp_ag_rtk_send_sco_config = false;
486 log_info("RTK SCO: 16k + CVSD");
487 hci_send_cmd(&hci_rtk_configure_sco_routing, 0x81, 0x90, 0x00, 0x00, 0x1a, 0x0c, 0x0c, 0x00, 0x01);
488 return;
489 }
490 #endif
491
492 switch (hsp_ag_state){
493
494 case HSP_W4_RING_ANSWER:
495 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
496 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
497 return;
498 }
499
500 hsp_ag_send_ok = 0;
501 hsp_ag_state = HSP_W2_CONNECT_SCO;
502
503 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, HSP_AG_OK);
504 break;
505
506 case HSP_W2_CONNECT_SCO:
507 if (!hci_can_send_command_packet_now()) return;
508 hsp_ag_state = HSP_W4_SCO_CONNECTED;
509 // bits 6-9 are 'don't use'
510 packet_types = hsp_ag_sco_packet_types ^ 0x3c0;
511 hci_send_cmd(&hci_setup_synchronous_connection, hsp_ag_rfcomm_handle, 8000, 8000, 0xFFFF, hci_get_sco_voice_setting(), 0xFF, packet_types);
512 break;
513
514 case HSP_W2_DISCONNECT_SCO:
515 hsp_ag_state = HSP_W4_SCO_DISCONNECTED;
516 gap_disconnect(hsp_ag_sco_handle);
517 break;
518
519 case HSP_W2_DISCONNECT_RFCOMM:
520 rfcomm_disconnect(hsp_ag_rfcomm_cid);
521 break;
522
523 case HSP_AUDIO_CONNECTION_ESTABLISHED:
524 case HSP_RFCOMM_CONNECTION_ESTABLISHED:
525
526 if (hsp_ag_microphone_gain >= 0){
527 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
528 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
529 return;
530 }
531 int gain = hsp_ag_microphone_gain;
532 hsp_ag_microphone_gain = -1;
533 char buffer[12];
534 btstack_snprintf_assert_complete(buffer, sizeof(buffer), "\r\n%s=%d\r\n",
535 HSP_MICROPHONE_GAIN, gain);
536 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, buffer);
537 break;
538 }
539
540 if (hsp_ag_speaker_gain >= 0){
541 if (!rfcomm_can_send_packet_now(hsp_ag_rfcomm_cid)) {
542 rfcomm_request_can_send_now_event(hsp_ag_rfcomm_cid);
543 return;
544 }
545 int gain = hsp_ag_speaker_gain;
546 hsp_ag_speaker_gain = -1;
547 char buffer[12];
548 btstack_snprintf_assert_complete(buffer, sizeof(buffer), "\r\n%s=%d\r\n",
549 HSP_SPEAKER_GAIN, gain);
550 hsp_ag_send_str_over_rfcomm(hsp_ag_rfcomm_cid, buffer);
551 break;
552 }
553 break;
554 default:
555 break;
556 }
557 }
558
559
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)560 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
561 UNUSED(channel); // ok: no channel for HCI_EVENT_PACKET and only single active RFCOMM channel
562
563 if (packet_type == RFCOMM_DATA_PACKET){
564 while ((size > 0) && ((packet[0] == '\n') || (packet[0] == '\r'))){
565 size--;
566 packet++;
567 }
568
569 if (strncmp((char *)packet, HSP_HS_BUTTON_PRESS, strlen(HSP_HS_BUTTON_PRESS)) == 0){
570 log_info("Received button press %s", HSP_HS_BUTTON_PRESS);
571 hsp_ag_send_ok = 1;
572 emit_event(HSP_SUBEVENT_BUTTON_PRESSED);
573 } else if (strncmp((char *)packet, HSP_HS_MICROPHONE_GAIN, strlen(HSP_HS_MICROPHONE_GAIN)) == 0){
574 uint8_t gain = (uint8_t)btstack_atoi((char*)&packet[strlen(HSP_HS_MICROPHONE_GAIN)]);
575 hsp_ag_send_ok = 1;
576 emit_event_with_value(HSP_SUBEVENT_MICROPHONE_GAIN_CHANGED, gain);
577
578 } else if (strncmp((char *)packet, HSP_HS_SPEAKER_GAIN, strlen(HSP_HS_SPEAKER_GAIN)) == 0){
579 uint8_t gain = (uint8_t)btstack_atoi((char*)&packet[strlen(HSP_HS_SPEAKER_GAIN)]);
580 hsp_ag_send_ok = 1;
581 emit_event_with_value(HSP_SUBEVENT_SPEAKER_GAIN_CHANGED, gain);
582
583 } else if (strncmp((char *)packet, "AT+", 3) == 0){
584 hsp_ag_send_error = 1;
585 if (!hsp_ag_callback) return;
586 if ((size + 4) > 255) return;
587 // re-use incoming buffer to avoid reserving buffers/memcpy - ugly but efficient
588 uint8_t * event = packet - 6;
589 event[0] = HCI_EVENT_HSP_META;
590 event[1] = (uint8_t) (size + 4);
591 event[2] = HSP_SUBEVENT_HS_COMMAND;
592 little_endian_store_16(event, 3, hsp_ag_rfcomm_handle);
593 event[5] = (uint8_t) size;
594 (*hsp_ag_callback)(HCI_EVENT_PACKET, 0, event, size+6);
595 }
596
597 hsp_run();
598 return;
599 }
600
601 if (packet_type != HCI_EVENT_PACKET) return;
602 uint8_t event = hci_event_packet_get_type(packet);
603 bd_addr_t event_addr;
604 uint16_t handle;
605 uint8_t status;
606
607 switch (event) {
608 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{
609 if (hsp_ag_state != HSP_W4_SCO_CONNECTED) break;
610 status = hci_event_synchronous_connection_complete_get_status(packet);
611 if (status != 0){
612 hsp_ag_state = HSP_RFCOMM_CONNECTION_ESTABLISHED;
613 log_error("(e)SCO Connection failed, status %u", status);
614 emit_event_audio_connected(status, hsp_ag_sco_handle);
615 break;
616 }
617
618 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr);
619 hsp_ag_sco_handle = hci_event_synchronous_connection_complete_get_handle(packet);
620 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet);
621 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots
622 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots
623 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes
624 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes
625
626 switch (link_type){
627 case 0x00:
628 log_info("SCO Connection established.");
629 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval);
630 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval);
631 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length);
632 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length);
633 break;
634 case 0x02:
635 log_info("eSCO Connection established.");
636 break;
637 default:
638 log_error("(e)SCO reserved link_type 0x%2x", link_type);
639 break;
640 }
641 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, "
642 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)", hsp_ag_sco_handle,
643 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length,
644 hci_event_synchronous_connection_complete_get_air_mode(packet));
645
646 if (hsp_ag_state == HSP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){
647 hsp_ag_state = HSP_W2_DISCONNECT_SCO;
648 break;
649 }
650
651 hsp_ag_state = HSP_AUDIO_CONNECTION_ESTABLISHED;
652 emit_event_audio_connected(status, hsp_ag_sco_handle);
653 break;
654 }
655
656 case RFCOMM_EVENT_INCOMING_CONNECTION:
657 if (hsp_ag_state != HSP_IDLE) return;
658
659 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr);
660 hsp_ag_rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet);
661 log_info("RFCOMM channel %u requested for %s with cid 0x%04x", rfcomm_event_incoming_connection_get_server_channel(packet), bd_addr_to_str(event_addr), hsp_ag_rfcomm_cid);
662 hsp_ag_state = HSP_W4_RFCOMM_CONNECTED;
663 rfcomm_accept_connection(hsp_ag_rfcomm_cid);
664 break;
665
666 case RFCOMM_EVENT_CHANNEL_OPENED:
667 log_info("RFCOMM_EVENT_CHANNEL_OPENED packet_handler type %u, packet[0] %x", packet_type, packet[0]);
668 status = rfcomm_event_channel_opened_get_status(packet);
669 if (status != ERROR_CODE_SUCCESS){
670 log_info("RFCOMM channel open failed, status %u", status);
671 hsp_ag_reset_state();
672 hsp_ag_state = HSP_IDLE;
673 memset(hsp_ag_remote, 0, 6);
674 } else {
675 hsp_ag_rfcomm_handle = rfcomm_event_channel_opened_get_con_handle(packet);
676 hsp_ag_rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet);
677 rfcomm_event_channel_opened_get_bd_addr(packet, hsp_ag_remote);
678 hsp_ag_mtu = rfcomm_event_channel_opened_get_max_frame_size(packet);
679 log_info("RFCOMM channel open succeeded. New RFCOMM Channel ID %u, max frame size %u, state %d", hsp_ag_rfcomm_cid, hsp_ag_mtu, hsp_ag_state);
680 hsp_ag_state = HSP_RFCOMM_CONNECTION_ESTABLISHED;
681 #ifdef ENABLE_RTK_PCM_WBS
682 hsp_ag_rtk_send_sco_config = true;
683 #endif
684 }
685 emit_event_rfcomm_connected(status);
686 break;
687
688 case RFCOMM_EVENT_CHANNEL_CLOSED:
689 hsp_ag_reset_state();
690 emit_event(HSP_SUBEVENT_RFCOMM_DISCONNECTION_COMPLETE);
691 break;
692
693 case RFCOMM_EVENT_CAN_SEND_NOW:
694 hsp_run();
695 break;
696
697 case HCI_EVENT_DISCONNECTION_COMPLETE:
698 handle = little_endian_read_16(packet,3);
699 if (handle == hsp_ag_sco_handle){
700 hci_con_handle_t sco_handle = hsp_ag_sco_handle;
701 hsp_ag_sco_handle = HCI_CON_HANDLE_INVALID;
702 hsp_ag_state = HSP_RFCOMM_CONNECTION_ESTABLISHED;
703 emit_event_audio_disconnected(sco_handle);
704 break;
705 }
706 break;
707
708 default:
709 break;
710 }
711
712 hsp_run();
713 }
714
handle_query_rfcomm_event(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)715 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
716 UNUSED(packet_type); // ok: handling own sdp events
717 UNUSED(channel); // ok: no channel
718 UNUSED(size); // ok: handling own sdp events
719
720 switch (packet[0]){
721 case SDP_EVENT_QUERY_RFCOMM_SERVICE:
722 hsp_ag_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet);
723 log_info("** Service name: '%s', RFCOMM port %u", sdp_event_query_rfcomm_service_get_name(packet), hsp_ag_channel_nr);
724 break;
725 case SDP_EVENT_QUERY_COMPLETE:
726 if (hsp_ag_channel_nr > 0){
727 hsp_ag_state = HSP_W4_RFCOMM_CONNECTED;
728 log_info("RFCOMM create channel. state %d", HSP_W4_RFCOMM_CONNECTED);
729 rfcomm_create_channel(packet_handler, hsp_ag_remote, hsp_ag_channel_nr, NULL);
730 break;
731 }
732 hsp_ag_reset_state();
733 log_info("Service not found, status %u.\n", sdp_event_query_complete_get_status(packet));
734 if (sdp_event_query_complete_get_status(packet)){
735 emit_event_with_value(HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE, sdp_event_query_complete_get_status(packet));
736 } else {
737 emit_event_with_value(HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE, SDP_SERVICE_NOT_FOUND);
738 }
739 break;
740 default:
741 break;
742 }
743 }
744
hsp_ag_set_sco_packet_types(uint16_t packet_types)745 void hsp_ag_set_sco_packet_types(uint16_t packet_types){
746 hsp_ag_sco_packet_types = packet_types;
747 }
748
749