xref: /btstack/src/classic/hfp.c (revision ca59be5193cced59664efef288ea86d02eaef3a4)
13deb3ec6SMatthias Ringwald /*
23deb3ec6SMatthias Ringwald  * Copyright (C) 2014 BlueKitchen GmbH
33deb3ec6SMatthias Ringwald  *
43deb3ec6SMatthias Ringwald  * Redistribution and use in source and binary forms, with or without
53deb3ec6SMatthias Ringwald  * modification, are permitted provided that the following conditions
63deb3ec6SMatthias Ringwald  * are met:
73deb3ec6SMatthias Ringwald  *
83deb3ec6SMatthias Ringwald  * 1. Redistributions of source code must retain the above copyright
93deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer.
103deb3ec6SMatthias Ringwald  * 2. Redistributions in binary form must reproduce the above copyright
113deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer in the
123deb3ec6SMatthias Ringwald  *    documentation and/or other materials provided with the distribution.
133deb3ec6SMatthias Ringwald  * 3. Neither the name of the copyright holders nor the names of
143deb3ec6SMatthias Ringwald  *    contributors may be used to endorse or promote products derived
153deb3ec6SMatthias Ringwald  *    from this software without specific prior written permission.
163deb3ec6SMatthias Ringwald  * 4. Any redistribution, use, or modification is done solely for
173deb3ec6SMatthias Ringwald  *    personal benefit and not for any commercial purpose or for
183deb3ec6SMatthias Ringwald  *    monetary gain.
193deb3ec6SMatthias Ringwald  *
203deb3ec6SMatthias Ringwald  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
213deb3ec6SMatthias Ringwald  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
223deb3ec6SMatthias Ringwald  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
233deb3ec6SMatthias Ringwald  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
243deb3ec6SMatthias Ringwald  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
253deb3ec6SMatthias Ringwald  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
263deb3ec6SMatthias Ringwald  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
273deb3ec6SMatthias Ringwald  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
283deb3ec6SMatthias Ringwald  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
293deb3ec6SMatthias Ringwald  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
303deb3ec6SMatthias Ringwald  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
313deb3ec6SMatthias Ringwald  * SUCH DAMAGE.
323deb3ec6SMatthias Ringwald  *
333deb3ec6SMatthias Ringwald  * Please inquire about commercial licensing options at
343deb3ec6SMatthias Ringwald  * [email protected]
353deb3ec6SMatthias Ringwald  *
363deb3ec6SMatthias Ringwald  */
37ab2c6ae4SMatthias Ringwald 
38ab2c6ae4SMatthias Ringwald #define __BTSTACK_FILE__ "hfp.c"
393deb3ec6SMatthias Ringwald 
403deb3ec6SMatthias Ringwald 
417907f069SMatthias Ringwald #include "btstack_config.h"
423deb3ec6SMatthias Ringwald 
433deb3ec6SMatthias Ringwald #include <stdint.h>
443deb3ec6SMatthias Ringwald #include <stdio.h>
453deb3ec6SMatthias Ringwald #include <stdlib.h>
463deb3ec6SMatthias Ringwald #include <string.h>
473deb3ec6SMatthias Ringwald #include <inttypes.h>
483deb3ec6SMatthias Ringwald 
49235946f1SMatthias Ringwald #include "bluetooth_sdp.h"
50023f2764SMatthias Ringwald #include "btstack_debug.h"
5159c6af15SMatthias Ringwald #include "btstack_event.h"
5259c6af15SMatthias Ringwald #include "btstack_memory.h"
5359c6af15SMatthias Ringwald #include "btstack_run_loop.h"
5459c6af15SMatthias Ringwald #include "classic/core.h"
55efda0b48SMatthias Ringwald #include "classic/sdp_client_rfcomm.h"
56746ccb7eSMatthias Ringwald #include "classic/sdp_server.h"
57023f2764SMatthias Ringwald #include "classic/sdp_util.h"
5859c6af15SMatthias Ringwald #include "hci.h"
5959c6af15SMatthias Ringwald #include "hci_cmd.h"
6059c6af15SMatthias Ringwald #include "hci_dump.h"
6159c6af15SMatthias Ringwald #include "l2cap.h"
623deb3ec6SMatthias Ringwald 
633deb3ec6SMatthias Ringwald #define HFP_HF_FEATURES_SIZE 10
643deb3ec6SMatthias Ringwald #define HFP_AG_FEATURES_SIZE 12
653deb3ec6SMatthias Ringwald 
663deb3ec6SMatthias Ringwald 
673deb3ec6SMatthias Ringwald static const char * hfp_hf_features[] = {
683deb3ec6SMatthias Ringwald     "EC and/or NR function",
693deb3ec6SMatthias Ringwald     "Three-way calling",
703deb3ec6SMatthias Ringwald     "CLI presentation capability",
713deb3ec6SMatthias Ringwald     "Voice recognition activation",
723deb3ec6SMatthias Ringwald     "Remote volume control",
733deb3ec6SMatthias Ringwald 
743deb3ec6SMatthias Ringwald     "Enhanced call status",
753deb3ec6SMatthias Ringwald     "Enhanced call control",
763deb3ec6SMatthias Ringwald 
773deb3ec6SMatthias Ringwald     "Codec negotiation",
783deb3ec6SMatthias Ringwald 
793deb3ec6SMatthias Ringwald     "HF Indicators",
803deb3ec6SMatthias Ringwald     "eSCO S4 (and T2) Settings Supported",
813deb3ec6SMatthias Ringwald     "Reserved for future definition"
823deb3ec6SMatthias Ringwald };
833deb3ec6SMatthias Ringwald 
843deb3ec6SMatthias Ringwald static const char * hfp_ag_features[] = {
853deb3ec6SMatthias Ringwald     "Three-way calling",
863deb3ec6SMatthias Ringwald     "EC and/or NR function",
873deb3ec6SMatthias Ringwald     "Voice recognition function",
883deb3ec6SMatthias Ringwald     "In-band ring tone capability",
893deb3ec6SMatthias Ringwald     "Attach a number to a voice tag",
903deb3ec6SMatthias Ringwald     "Ability to reject a call",
913deb3ec6SMatthias Ringwald     "Enhanced call status",
923deb3ec6SMatthias Ringwald     "Enhanced call control",
933deb3ec6SMatthias Ringwald     "Extended Error Result Codes",
943deb3ec6SMatthias Ringwald     "Codec negotiation",
953deb3ec6SMatthias Ringwald     "HF Indicators",
963deb3ec6SMatthias Ringwald     "eSCO S4 (and T2) Settings Supported",
973deb3ec6SMatthias Ringwald     "Reserved for future definition"
983deb3ec6SMatthias Ringwald };
993deb3ec6SMatthias Ringwald 
1008f2a52f4SMatthias Ringwald static btstack_linked_list_t hfp_connections = NULL;
101ce263fc8SMatthias Ringwald static void parse_sequence(hfp_connection_t * context);
102*ca59be51SMatthias Ringwald 
103*ca59be51SMatthias Ringwald static btstack_packet_handler_t hfp_hf_callback;
104*ca59be51SMatthias Ringwald static btstack_packet_handler_t hfp_ag_callback;
105*ca59be51SMatthias Ringwald 
106*ca59be51SMatthias Ringwald static btstack_packet_handler_t hfp_hf_rfcomm_packet_handler;
107*ca59be51SMatthias Ringwald static btstack_packet_handler_t hfp_ag_rfcomm_packet_handler;
108f4000eebSMatthias Ringwald 
109eddcd308SMatthias Ringwald static hfp_connection_t * sco_establishment_active;
110eddcd308SMatthias Ringwald 
111*ca59be51SMatthias Ringwald void hfp_set_hf_callback(btstack_packet_handler_t callback){
112*ca59be51SMatthias Ringwald     hfp_hf_callback = callback;
113*ca59be51SMatthias Ringwald }
114*ca59be51SMatthias Ringwald 
115*ca59be51SMatthias Ringwald void hfp_set_ag_callback(btstack_packet_handler_t callback){
116*ca59be51SMatthias Ringwald     hfp_ag_callback = callback;
117f4000eebSMatthias Ringwald }
1183deb3ec6SMatthias Ringwald 
1193deb3ec6SMatthias Ringwald const char * hfp_hf_feature(int index){
1203deb3ec6SMatthias Ringwald     if (index > HFP_HF_FEATURES_SIZE){
1213deb3ec6SMatthias Ringwald         return hfp_hf_features[HFP_HF_FEATURES_SIZE];
1223deb3ec6SMatthias Ringwald     }
1233deb3ec6SMatthias Ringwald     return hfp_hf_features[index];
1243deb3ec6SMatthias Ringwald }
1253deb3ec6SMatthias Ringwald 
1263deb3ec6SMatthias Ringwald const char * hfp_ag_feature(int index){
1273deb3ec6SMatthias Ringwald     if (index > HFP_AG_FEATURES_SIZE){
1283deb3ec6SMatthias Ringwald         return hfp_ag_features[HFP_AG_FEATURES_SIZE];
1293deb3ec6SMatthias Ringwald     }
1303deb3ec6SMatthias Ringwald     return hfp_ag_features[index];
1313deb3ec6SMatthias Ringwald }
1323deb3ec6SMatthias Ringwald 
1333deb3ec6SMatthias Ringwald int send_str_over_rfcomm(uint16_t cid, char * command){
1343deb3ec6SMatthias Ringwald     if (!rfcomm_can_send_packet_now(cid)) return 1;
13574386ee0SMatthias Ringwald     log_info("HFP_TX %s", command);
13628190c0bSMatthias Ringwald     int err = rfcomm_send(cid, (uint8_t*) command, strlen(command));
1373deb3ec6SMatthias Ringwald     if (err){
13828190c0bSMatthias Ringwald         log_error("rfcomm_send -> error 0x%02x \n", err);
1393deb3ec6SMatthias Ringwald     }
1403deb3ec6SMatthias Ringwald     return 1;
1413deb3ec6SMatthias Ringwald }
1423deb3ec6SMatthias Ringwald 
1436a7f44bdSMilanka Ringwald int hfp_supports_codec(uint8_t codec, int codecs_nr, uint8_t * codecs){
144e8d1dc0dSMatthias Ringwald 
145e8d1dc0dSMatthias Ringwald     // mSBC requires support for eSCO connections
146e8d1dc0dSMatthias Ringwald     if (codec == HFP_CODEC_MSBC && !hci_extended_sco_link_supported()) return 0;
147e8d1dc0dSMatthias Ringwald 
148df327ff3SMilanka Ringwald     int i;
149df327ff3SMilanka Ringwald     for (i = 0; i < codecs_nr; i++){
150e8d1dc0dSMatthias Ringwald         if (codecs[i] != codec) continue;
151e8d1dc0dSMatthias Ringwald         return 1;
152df327ff3SMilanka Ringwald     }
153df327ff3SMilanka Ringwald     return 0;
154df327ff3SMilanka Ringwald }
155df327ff3SMilanka Ringwald 
156d715cf51SMatthias Ringwald void hfp_hf_drop_mSBC_if_eSCO_not_supported(uint8_t * codecs, uint8_t * codecs_nr){
157d715cf51SMatthias Ringwald     if (hci_extended_sco_link_supported()) return;
158d715cf51SMatthias Ringwald     uint8_t tmp_codecs[HFP_MAX_NUM_CODECS];
159d715cf51SMatthias Ringwald     int i;
160d715cf51SMatthias Ringwald     int tmp_codec_nr = 0;
161d715cf51SMatthias Ringwald     for (i=0; i < *codecs_nr; i++){
162d715cf51SMatthias Ringwald         if (codecs[i] == HFP_CODEC_MSBC) continue;
163d715cf51SMatthias Ringwald         tmp_codecs[tmp_codec_nr++] = codecs[i];
164d715cf51SMatthias Ringwald     }
165d715cf51SMatthias Ringwald     *codecs_nr = tmp_codec_nr;
166d715cf51SMatthias Ringwald     memcpy(codecs, tmp_codecs, tmp_codec_nr);
167d715cf51SMatthias Ringwald }
168d715cf51SMatthias Ringwald 
1693deb3ec6SMatthias Ringwald // UTILS
1703deb3ec6SMatthias Ringwald int get_bit(uint16_t bitmap, int position){
1713deb3ec6SMatthias Ringwald     return (bitmap >> position) & 1;
1723deb3ec6SMatthias Ringwald }
1733deb3ec6SMatthias Ringwald 
1743deb3ec6SMatthias Ringwald int store_bit(uint32_t bitmap, int position, uint8_t value){
1753deb3ec6SMatthias Ringwald     if (value){
1763deb3ec6SMatthias Ringwald         bitmap |= 1 << position;
1773deb3ec6SMatthias Ringwald     } else {
1783deb3ec6SMatthias Ringwald         bitmap &= ~ (1 << position);
1793deb3ec6SMatthias Ringwald     }
1803deb3ec6SMatthias Ringwald     return bitmap;
1813deb3ec6SMatthias Ringwald }
1823deb3ec6SMatthias Ringwald 
1833deb3ec6SMatthias Ringwald int join(char * buffer, int buffer_size, uint8_t * values, int values_nr){
1843deb3ec6SMatthias Ringwald     if (buffer_size < values_nr * 3) return 0;
1853deb3ec6SMatthias Ringwald     int i;
1863deb3ec6SMatthias Ringwald     int offset = 0;
1873deb3ec6SMatthias Ringwald     for (i = 0; i < values_nr-1; i++) {
1883deb3ec6SMatthias Ringwald       offset += snprintf(buffer+offset, buffer_size-offset, "%d,", values[i]); // puts string into buffer
1893deb3ec6SMatthias Ringwald     }
1903deb3ec6SMatthias Ringwald     if (i<values_nr){
1913deb3ec6SMatthias Ringwald         offset += snprintf(buffer+offset, buffer_size-offset, "%d", values[i]);
1923deb3ec6SMatthias Ringwald     }
1933deb3ec6SMatthias Ringwald     return offset;
1943deb3ec6SMatthias Ringwald }
1953deb3ec6SMatthias Ringwald 
1963deb3ec6SMatthias Ringwald int join_bitmap(char * buffer, int buffer_size, uint32_t values, int values_nr){
1973deb3ec6SMatthias Ringwald     if (buffer_size < values_nr * 3) return 0;
1983deb3ec6SMatthias Ringwald 
1993deb3ec6SMatthias Ringwald     int i;
2003deb3ec6SMatthias Ringwald     int offset = 0;
2013deb3ec6SMatthias Ringwald     for (i = 0; i < values_nr-1; i++) {
2023deb3ec6SMatthias Ringwald       offset += snprintf(buffer+offset, buffer_size-offset, "%d,", get_bit(values,i)); // puts string into buffer
2033deb3ec6SMatthias Ringwald     }
2043deb3ec6SMatthias Ringwald 
2053deb3ec6SMatthias Ringwald     if (i<values_nr){
2063deb3ec6SMatthias Ringwald         offset += snprintf(buffer+offset, buffer_size-offset, "%d", get_bit(values,i));
2073deb3ec6SMatthias Ringwald     }
2083deb3ec6SMatthias Ringwald     return offset;
2093deb3ec6SMatthias Ringwald }
2103deb3ec6SMatthias Ringwald 
211*ca59be51SMatthias Ringwald static void hfp_emit_event_for_context(hfp_connection_t * hfp_connection, uint8_t * packet, uint16_t size){
212*ca59be51SMatthias Ringwald     if (!hfp_connection) return;
213*ca59be51SMatthias Ringwald     btstack_packet_handler_t callback = NULL;
214*ca59be51SMatthias Ringwald     switch (hfp_connection->local_role){
215*ca59be51SMatthias Ringwald         case HFP_ROLE_HF:
216*ca59be51SMatthias Ringwald             callback = hfp_hf_callback;
217*ca59be51SMatthias Ringwald         case HFP_ROLE_AG:
218*ca59be51SMatthias Ringwald             callback = hfp_ag_callback;
219*ca59be51SMatthias Ringwald         default:
220*ca59be51SMatthias Ringwald             return;
221*ca59be51SMatthias Ringwald     }
222*ca59be51SMatthias Ringwald     (*callback)(HCI_EVENT_PACKET, 0, packet, size);
223*ca59be51SMatthias Ringwald }
224*ca59be51SMatthias Ringwald 
225*ca59be51SMatthias Ringwald void hfp_emit_simple_event(hfp_connection_t * hfp_connection, uint8_t event_subtype){
226a0ffb263SMatthias Ringwald     uint8_t event[3];
227a0ffb263SMatthias Ringwald     event[0] = HCI_EVENT_HFP_META;
228a0ffb263SMatthias Ringwald     event[1] = sizeof(event) - 2;
229a0ffb263SMatthias Ringwald     event[2] = event_subtype;
230*ca59be51SMatthias Ringwald     hfp_emit_event_for_context(hfp_connection, event, sizeof(event));
231a0ffb263SMatthias Ringwald }
232a0ffb263SMatthias Ringwald 
233*ca59be51SMatthias Ringwald void hfp_emit_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, uint8_t value){
2343deb3ec6SMatthias Ringwald     uint8_t event[4];
2353deb3ec6SMatthias Ringwald     event[0] = HCI_EVENT_HFP_META;
2363deb3ec6SMatthias Ringwald     event[1] = sizeof(event) - 2;
2373deb3ec6SMatthias Ringwald     event[2] = event_subtype;
2383deb3ec6SMatthias Ringwald     event[3] = value; // status 0 == OK
239*ca59be51SMatthias Ringwald     hfp_emit_event_for_context(hfp_connection, event, sizeof(event));
2403deb3ec6SMatthias Ringwald }
2413deb3ec6SMatthias Ringwald 
242*ca59be51SMatthias Ringwald void hfp_emit_slc_connection_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr){
2438901a7c4SMatthias Ringwald     uint8_t event[12];
2446a7f44bdSMilanka Ringwald     int pos = 0;
2456a7f44bdSMilanka Ringwald     event[pos++] = HCI_EVENT_HFP_META;
2466a7f44bdSMilanka Ringwald     event[pos++] = sizeof(event) - 2;
247d0c4aea6SMilanka Ringwald     event[pos++] = HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_ESTABLISHED;
2486a7f44bdSMilanka Ringwald     event[pos++] = status; // status 0 == OK
2496a7f44bdSMilanka Ringwald     little_endian_store_16(event, pos, con_handle);
2506a7f44bdSMilanka Ringwald     pos += 2;
2516a7f44bdSMilanka Ringwald     reverse_bd_addr(addr,&event[pos]);
2526a7f44bdSMilanka Ringwald     pos += 6;
253*ca59be51SMatthias Ringwald     hfp_emit_event_for_context(hfp_connection, event, sizeof(event));
254a0653c3bSMilanka Ringwald }
255a0653c3bSMilanka Ringwald 
256*ca59be51SMatthias Ringwald static void hfp_emit_sco_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr, uint8_t  negotiated_codec){
257d0c4aea6SMilanka Ringwald     uint8_t event[13];
258d0c4aea6SMilanka Ringwald     int pos = 0;
259d0c4aea6SMilanka Ringwald     event[pos++] = HCI_EVENT_HFP_META;
260d0c4aea6SMilanka Ringwald     event[pos++] = sizeof(event) - 2;
261d0c4aea6SMilanka Ringwald     event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_ESTABLISHED;
262d0c4aea6SMilanka Ringwald     event[pos++] = status; // status 0 == OK
263d0c4aea6SMilanka Ringwald     little_endian_store_16(event, pos, con_handle);
264d0c4aea6SMilanka Ringwald     pos += 2;
265d0c4aea6SMilanka Ringwald     reverse_bd_addr(addr,&event[pos]);
266d0c4aea6SMilanka Ringwald     pos += 6;
267d0c4aea6SMilanka Ringwald     event[pos++] = negotiated_codec;
268*ca59be51SMatthias Ringwald     hfp_emit_event_for_context(hfp_connection, event, sizeof(event));
269d0c4aea6SMilanka Ringwald }
270d0c4aea6SMilanka Ringwald 
271*ca59be51SMatthias Ringwald void hfp_emit_string_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, const char * value){
272c1797c7dSMatthias Ringwald     uint8_t event[40];
273aa4dd815SMatthias Ringwald     event[0] = HCI_EVENT_HFP_META;
274aa4dd815SMatthias Ringwald     event[1] = sizeof(event) - 2;
275aa4dd815SMatthias Ringwald     event[2] = event_subtype;
276adaba9f3SMatthias Ringwald     int size = ( strlen(value) < sizeof(event) - 4) ? (int) strlen(value) : (int) sizeof(event) - 4;
277aa4dd815SMatthias Ringwald     strncpy((char*)&event[3], value, size);
278aa4dd815SMatthias Ringwald     event[3 + size] = 0;
279*ca59be51SMatthias Ringwald     hfp_emit_event_for_context(hfp_connection, event, sizeof(event));
280aa4dd815SMatthias Ringwald }
281aa4dd815SMatthias Ringwald 
2820cb5b971SMatthias Ringwald btstack_linked_list_t * hfp_get_connections(void){
2838f2a52f4SMatthias Ringwald     return (btstack_linked_list_t *) &hfp_connections;
2843deb3ec6SMatthias Ringwald }
2853deb3ec6SMatthias Ringwald 
2863deb3ec6SMatthias Ringwald hfp_connection_t * get_hfp_connection_context_for_rfcomm_cid(uint16_t cid){
287665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
288665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, hfp_get_connections());
289665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
290a0ffb263SMatthias Ringwald         hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it);
291a0ffb263SMatthias Ringwald         if (hfp_connection->rfcomm_cid == cid){
292a0ffb263SMatthias Ringwald             return hfp_connection;
2933deb3ec6SMatthias Ringwald         }
2943deb3ec6SMatthias Ringwald     }
2953deb3ec6SMatthias Ringwald     return NULL;
2963deb3ec6SMatthias Ringwald }
2973deb3ec6SMatthias Ringwald 
2983deb3ec6SMatthias Ringwald hfp_connection_t * get_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr){
299665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
300665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, hfp_get_connections());
301665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
302a0ffb263SMatthias Ringwald         hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it);
303a0ffb263SMatthias Ringwald         if (memcmp(hfp_connection->remote_addr, bd_addr, 6) == 0) {
304a0ffb263SMatthias Ringwald             return hfp_connection;
3053deb3ec6SMatthias Ringwald         }
3063deb3ec6SMatthias Ringwald     }
3073deb3ec6SMatthias Ringwald     return NULL;
3083deb3ec6SMatthias Ringwald }
3093deb3ec6SMatthias Ringwald 
310aa4dd815SMatthias Ringwald hfp_connection_t * get_hfp_connection_context_for_sco_handle(uint16_t handle){
311665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
312665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, hfp_get_connections());
313665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
314a0ffb263SMatthias Ringwald         hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it);
315a0ffb263SMatthias Ringwald         if (hfp_connection->sco_handle == handle){
316a0ffb263SMatthias Ringwald             return hfp_connection;
3173deb3ec6SMatthias Ringwald         }
3183deb3ec6SMatthias Ringwald     }
3193deb3ec6SMatthias Ringwald     return NULL;
3203deb3ec6SMatthias Ringwald }
3213deb3ec6SMatthias Ringwald 
322d97d752dSMilanka Ringwald hfp_connection_t * get_hfp_connection_context_for_acl_handle(uint16_t handle){
323d97d752dSMilanka Ringwald     btstack_linked_list_iterator_t it;
324d97d752dSMilanka Ringwald     btstack_linked_list_iterator_init(&it, hfp_get_connections());
325d97d752dSMilanka Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
326d97d752dSMilanka Ringwald         hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it);
327d97d752dSMilanka Ringwald         if (hfp_connection->acl_handle == handle){
328d97d752dSMilanka Ringwald             return hfp_connection;
329d97d752dSMilanka Ringwald         }
330d97d752dSMilanka Ringwald     }
331d97d752dSMilanka Ringwald     return NULL;
332d97d752dSMilanka Ringwald }
333d97d752dSMilanka Ringwald 
334a0ffb263SMatthias Ringwald void hfp_reset_context_flags(hfp_connection_t * hfp_connection){
335a0ffb263SMatthias Ringwald     if (!hfp_connection) return;
336a0ffb263SMatthias Ringwald     hfp_connection->ok_pending = 0;
337a0ffb263SMatthias Ringwald     hfp_connection->send_error = 0;
3383deb3ec6SMatthias Ringwald 
339a0ffb263SMatthias Ringwald     hfp_connection->keep_byte = 0;
3403deb3ec6SMatthias Ringwald 
341a0ffb263SMatthias Ringwald     hfp_connection->change_status_update_for_individual_ag_indicators = 0;
342a0ffb263SMatthias Ringwald     hfp_connection->operator_name_changed = 0;
3433deb3ec6SMatthias Ringwald 
344a0ffb263SMatthias Ringwald     hfp_connection->enable_extended_audio_gateway_error_report = 0;
345a0ffb263SMatthias Ringwald     hfp_connection->extended_audio_gateway_error = 0;
3463deb3ec6SMatthias Ringwald 
347a0ffb263SMatthias Ringwald     // establish codecs hfp_connection
348a0ffb263SMatthias Ringwald     hfp_connection->suggested_codec = 0;
3497522e673SMatthias Ringwald     hfp_connection->negotiated_codec = 0;
350a0ffb263SMatthias Ringwald     hfp_connection->codec_confirmed = 0;
3513deb3ec6SMatthias Ringwald 
352a0ffb263SMatthias Ringwald     hfp_connection->establish_audio_connection = 0;
353a0ffb263SMatthias Ringwald     hfp_connection->call_waiting_notification_enabled = 0;
354a0ffb263SMatthias Ringwald     hfp_connection->command = HFP_CMD_NONE;
355a0ffb263SMatthias Ringwald     hfp_connection->enable_status_update_for_ag_indicators = 0xFF;
3563deb3ec6SMatthias Ringwald }
3573deb3ec6SMatthias Ringwald 
358fffdd288SMatthias Ringwald static hfp_connection_t * create_hfp_connection_context(void){
359a0ffb263SMatthias Ringwald     hfp_connection_t * hfp_connection = btstack_memory_hfp_connection_get();
360a0ffb263SMatthias Ringwald     if (!hfp_connection) return NULL;
3613deb3ec6SMatthias Ringwald     // init state
362a0ffb263SMatthias Ringwald     memset(hfp_connection,0, sizeof(hfp_connection_t));
3633deb3ec6SMatthias Ringwald 
364a0ffb263SMatthias Ringwald     hfp_connection->state = HFP_IDLE;
365a0ffb263SMatthias Ringwald     hfp_connection->call_state = HFP_CALL_IDLE;
366a0ffb263SMatthias Ringwald     hfp_connection->codecs_state = HFP_CODECS_IDLE;
367aa4dd815SMatthias Ringwald 
368a0ffb263SMatthias Ringwald     hfp_connection->parser_state = HFP_PARSER_CMD_HEADER;
369a0ffb263SMatthias Ringwald     hfp_connection->command = HFP_CMD_NONE;
3703deb3ec6SMatthias Ringwald 
371a0ffb263SMatthias Ringwald     hfp_reset_context_flags(hfp_connection);
3723deb3ec6SMatthias Ringwald 
373d63c37a1SMatthias Ringwald     btstack_linked_list_add(&hfp_connections, (btstack_linked_item_t*)hfp_connection);
374a0ffb263SMatthias Ringwald     return hfp_connection;
3753deb3ec6SMatthias Ringwald }
3763deb3ec6SMatthias Ringwald 
377a0ffb263SMatthias Ringwald static void remove_hfp_connection_context(hfp_connection_t * hfp_connection){
378a0ffb263SMatthias Ringwald     btstack_linked_list_remove(&hfp_connections, (btstack_linked_item_t*) hfp_connection);
37909a233a1SMatthias Ringwald     btstack_memory_hfp_connection_free(hfp_connection);
3803deb3ec6SMatthias Ringwald }
3813deb3ec6SMatthias Ringwald 
382323d3000SMatthias Ringwald static hfp_connection_t * provide_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t local_role){
383a0ffb263SMatthias Ringwald     hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr);
384a0ffb263SMatthias Ringwald     if (hfp_connection) return  hfp_connection;
385a0ffb263SMatthias Ringwald     hfp_connection = create_hfp_connection_context();
386a0ffb263SMatthias Ringwald     memcpy(hfp_connection->remote_addr, bd_addr, 6);
387323d3000SMatthias Ringwald     hfp_connection->local_role = local_role;
388a0ffb263SMatthias Ringwald     return hfp_connection;
3893deb3ec6SMatthias Ringwald }
3903deb3ec6SMatthias Ringwald 
391aa4dd815SMatthias Ringwald /* @param network.
392aa4dd815SMatthias Ringwald  * 0 == no ability to reject a call.
393aa4dd815SMatthias Ringwald  * 1 == ability to reject a call.
394aa4dd815SMatthias Ringwald  */
3953deb3ec6SMatthias Ringwald 
3963deb3ec6SMatthias Ringwald /* @param suported_features
3973deb3ec6SMatthias Ringwald  * HF bit 0: EC and/or NR function (yes/no, 1 = yes, 0 = no)
3983deb3ec6SMatthias Ringwald  * HF bit 1: Call waiting or three-way calling(yes/no, 1 = yes, 0 = no)
3993deb3ec6SMatthias Ringwald  * HF bit 2: CLI presentation capability (yes/no, 1 = yes, 0 = no)
4003deb3ec6SMatthias Ringwald  * HF bit 3: Voice recognition activation (yes/no, 1= yes, 0 = no)
4013deb3ec6SMatthias Ringwald  * HF bit 4: Remote volume control (yes/no, 1 = yes, 0 = no)
4023deb3ec6SMatthias Ringwald  * HF bit 5: Wide band speech (yes/no, 1 = yes, 0 = no)
4033deb3ec6SMatthias Ringwald  */
4043deb3ec6SMatthias Ringwald  /* Bit position:
4053deb3ec6SMatthias Ringwald  * AG bit 0: Three-way calling (yes/no, 1 = yes, 0 = no)
4063deb3ec6SMatthias Ringwald  * AG bit 1: EC and/or NR function (yes/no, 1 = yes, 0 = no)
4073deb3ec6SMatthias Ringwald  * AG bit 2: Voice recognition function (yes/no, 1 = yes, 0 = no)
4083deb3ec6SMatthias Ringwald  * AG bit 3: In-band ring tone capability (yes/no, 1 = yes, 0 = no)
4093deb3ec6SMatthias Ringwald  * AG bit 4: Attach a phone number to a voice tag (yes/no, 1 = yes, 0 = no)
4103deb3ec6SMatthias Ringwald  * AG bit 5: Wide band speech (yes/no, 1 = yes, 0 = no)
4113deb3ec6SMatthias Ringwald  */
4123deb3ec6SMatthias Ringwald 
4139b1c3b4dSMatthias Ringwald void hfp_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t service_uuid, int rfcomm_channel_nr, const char * name){
4143deb3ec6SMatthias Ringwald     uint8_t* attribute;
4153deb3ec6SMatthias Ringwald     de_create_sequence(service);
4163deb3ec6SMatthias Ringwald 
4173deb3ec6SMatthias Ringwald     // 0x0000 "Service Record Handle"
418235946f1SMatthias Ringwald     de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE);
4199b1c3b4dSMatthias Ringwald     de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle);
4203deb3ec6SMatthias Ringwald 
4213deb3ec6SMatthias Ringwald     // 0x0001 "Service Class ID List"
422235946f1SMatthias Ringwald     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
4233deb3ec6SMatthias Ringwald     attribute = de_push_sequence(service);
4243deb3ec6SMatthias Ringwald     {
4253deb3ec6SMatthias Ringwald         //  "UUID for Service"
4263deb3ec6SMatthias Ringwald         de_add_number(attribute, DE_UUID, DE_SIZE_16, service_uuid);
427235946f1SMatthias Ringwald         de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO);
4283deb3ec6SMatthias Ringwald     }
4293deb3ec6SMatthias Ringwald     de_pop_sequence(service, attribute);
4303deb3ec6SMatthias Ringwald 
4313deb3ec6SMatthias Ringwald     // 0x0004 "Protocol Descriptor List"
432235946f1SMatthias Ringwald     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
4333deb3ec6SMatthias Ringwald     attribute = de_push_sequence(service);
4343deb3ec6SMatthias Ringwald     {
4353deb3ec6SMatthias Ringwald         uint8_t* l2cpProtocol = de_push_sequence(attribute);
4363deb3ec6SMatthias Ringwald         {
437235946f1SMatthias Ringwald             de_add_number(l2cpProtocol,  DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
4383deb3ec6SMatthias Ringwald         }
4393deb3ec6SMatthias Ringwald         de_pop_sequence(attribute, l2cpProtocol);
4403deb3ec6SMatthias Ringwald 
4413deb3ec6SMatthias Ringwald         uint8_t* rfcomm = de_push_sequence(attribute);
4423deb3ec6SMatthias Ringwald         {
443235946f1SMatthias Ringwald             de_add_number(rfcomm,  DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM);  // rfcomm_service
4443deb3ec6SMatthias Ringwald             de_add_number(rfcomm,  DE_UINT, DE_SIZE_8,  rfcomm_channel_nr);  // rfcomm channel
4453deb3ec6SMatthias Ringwald         }
4463deb3ec6SMatthias Ringwald         de_pop_sequence(attribute, rfcomm);
4473deb3ec6SMatthias Ringwald     }
4483deb3ec6SMatthias Ringwald     de_pop_sequence(service, attribute);
4493deb3ec6SMatthias Ringwald 
4503deb3ec6SMatthias Ringwald 
4513deb3ec6SMatthias Ringwald     // 0x0005 "Public Browse Group"
452235946f1SMatthias Ringwald     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group
4533deb3ec6SMatthias Ringwald     attribute = de_push_sequence(service);
4543deb3ec6SMatthias Ringwald     {
455235946f1SMatthias Ringwald         de_add_number(attribute,  DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT);
4563deb3ec6SMatthias Ringwald     }
4573deb3ec6SMatthias Ringwald     de_pop_sequence(service, attribute);
4583deb3ec6SMatthias Ringwald 
4593deb3ec6SMatthias Ringwald     // 0x0009 "Bluetooth Profile Descriptor List"
460235946f1SMatthias Ringwald     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
4613deb3ec6SMatthias Ringwald     attribute = de_push_sequence(service);
4623deb3ec6SMatthias Ringwald     {
4633deb3ec6SMatthias Ringwald         uint8_t *sppProfile = de_push_sequence(attribute);
4643deb3ec6SMatthias Ringwald         {
465235946f1SMatthias Ringwald             de_add_number(sppProfile,  DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HANDSFREE);
4663deb3ec6SMatthias Ringwald             de_add_number(sppProfile,  DE_UINT, DE_SIZE_16, 0x0107); // Verision 1.7
4673deb3ec6SMatthias Ringwald         }
4683deb3ec6SMatthias Ringwald         de_pop_sequence(attribute, sppProfile);
4693deb3ec6SMatthias Ringwald     }
4703deb3ec6SMatthias Ringwald     de_pop_sequence(service, attribute);
4713deb3ec6SMatthias Ringwald 
4723deb3ec6SMatthias Ringwald     // 0x0100 "Service Name"
4733deb3ec6SMatthias Ringwald     de_add_number(service,  DE_UINT, DE_SIZE_16, 0x0100);
4743deb3ec6SMatthias Ringwald     de_add_data(service,  DE_STRING, strlen(name), (uint8_t *) name);
4753deb3ec6SMatthias Ringwald }
4763deb3ec6SMatthias Ringwald 
4773deb3ec6SMatthias Ringwald static hfp_connection_t * connection_doing_sdp_query = NULL;
478a8747467SMatthias Ringwald 
4796c927b22SMatthias Ringwald static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
4808a46ec40SMatthias Ringwald     UNUSED(packet_type);    // ok: handling own sdp events
4818a46ec40SMatthias Ringwald     UNUSED(channel);        // ok: no channel
4828a46ec40SMatthias Ringwald     UNUSED(size);           // ok: handling own sdp events
4839ec2630cSMatthias Ringwald 
484a0ffb263SMatthias Ringwald     hfp_connection_t * hfp_connection = connection_doing_sdp_query;
48584904e95SMilanka Ringwald     if (!hfp_connection) {
48684904e95SMilanka Ringwald         log_error("handle_query_rfcomm_event, no connection");
48784904e95SMilanka Ringwald         return;
48884904e95SMilanka Ringwald     }
4893deb3ec6SMatthias Ringwald 
4900e2df43fSMatthias Ringwald     switch (hci_event_packet_get_type(packet)){
4915611a760SMatthias Ringwald         case SDP_EVENT_QUERY_RFCOMM_SERVICE:
492a0ffb263SMatthias Ringwald             hfp_connection->rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet);
4933deb3ec6SMatthias Ringwald             break;
4945611a760SMatthias Ringwald         case SDP_EVENT_QUERY_COMPLETE:
4953deb3ec6SMatthias Ringwald             connection_doing_sdp_query = NULL;
496a0ffb263SMatthias Ringwald             if (hfp_connection->rfcomm_channel_nr > 0){
497a0ffb263SMatthias Ringwald                 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED;
498a0ffb263SMatthias Ringwald                 log_info("HFP: SDP_EVENT_QUERY_COMPLETE context %p, addr %s, state %d", hfp_connection, bd_addr_to_str( hfp_connection->remote_addr),  hfp_connection->state);
499*ca59be51SMatthias Ringwald                 btstack_packet_handler_t packet_handler = hfp_connection->local_role == HFP_ROLE_AG ? hfp_ag_rfcomm_packet_handler : hfp_hf_rfcomm_packet_handler;
500*ca59be51SMatthias Ringwald                 rfcomm_create_channel(packet_handler, hfp_connection->remote_addr, hfp_connection->rfcomm_channel_nr, NULL);
5013deb3ec6SMatthias Ringwald                 break;
5023deb3ec6SMatthias Ringwald             }
50384904e95SMilanka Ringwald             hfp_connection->state = HFP_IDLE;
504*ca59be51SMatthias Ringwald             hfp_emit_slc_connection_event(hfp_connection, sdp_event_query_complete_get_status(packet), HCI_CON_HANDLE_INVALID, hfp_connection->remote_addr);
50572b50801SMatthias Ringwald             log_info("rfcomm service not found, status %u.", sdp_event_query_complete_get_status(packet));
5063deb3ec6SMatthias Ringwald             break;
5073deb3ec6SMatthias Ringwald         default:
5083deb3ec6SMatthias Ringwald             break;
5093deb3ec6SMatthias Ringwald     }
5103deb3ec6SMatthias Ringwald }
5113deb3ec6SMatthias Ringwald 
512eddcd308SMatthias Ringwald static void hfp_handle_failed_sco_connection(uint8_t status){
513eddcd308SMatthias Ringwald 
514eddcd308SMatthias Ringwald     if (!sco_establishment_active){
515eddcd308SMatthias Ringwald         log_error("(e)SCO Connection failed but not started by us");
516eddcd308SMatthias Ringwald         return;
517eddcd308SMatthias Ringwald     }
5186c5b2002SMatthias Ringwald     log_error("(e)SCO Connection failed status 0x%02x", status);
519eddcd308SMatthias Ringwald 
520eddcd308SMatthias Ringwald     // invalid params / unspecified error
521eddcd308SMatthias Ringwald     if (status != 0x11 && status != 0x1f) return;
522eddcd308SMatthias Ringwald 
523eddcd308SMatthias Ringwald      switch (sco_establishment_active->link_setting){
524eddcd308SMatthias Ringwald         case HFP_LINK_SETTINGS_D0:
525eddcd308SMatthias Ringwald             return; // no other option left
526eddcd308SMatthias Ringwald         case HFP_LINK_SETTINGS_D1:
527eddcd308SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D0;
528eddcd308SMatthias Ringwald             break;
529eddcd308SMatthias Ringwald         case HFP_LINK_SETTINGS_S1:
530eddcd308SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1;
531eddcd308SMatthias Ringwald             break;
532eddcd308SMatthias Ringwald         case HFP_LINK_SETTINGS_S2:
533eddcd308SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S1;
534eddcd308SMatthias Ringwald             break;
5357522e673SMatthias Ringwald         case HFP_LINK_SETTINGS_S3:
5367522e673SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S2;
5377522e673SMatthias Ringwald             break;
5387522e673SMatthias Ringwald         case HFP_LINK_SETTINGS_S4:
539eddcd308SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_S3;
540eddcd308SMatthias Ringwald             break;
5417522e673SMatthias Ringwald         case HFP_LINK_SETTINGS_T1:
5427522e673SMatthias Ringwald             log_info("T1 failed, fallback to CVSD - D1");
5437522e673SMatthias Ringwald             sco_establishment_active->negotiated_codec = HFP_CODEC_CVSD;
544bc1b1537SMilanka Ringwald             sco_establishment_active->sco_for_msbc_failed = 1;
545bc1b1537SMilanka Ringwald             sco_establishment_active->command = HFP_CMD_AG_SEND_COMMON_CODEC;
5467522e673SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1;
5477522e673SMatthias Ringwald             break;
5487522e673SMatthias Ringwald         case HFP_LINK_SETTINGS_T2:
5497522e673SMatthias Ringwald             sco_establishment_active->link_setting = HFP_LINK_SETTINGS_T1;
5507522e673SMatthias Ringwald             break;
551eddcd308SMatthias Ringwald     }
552eddcd308SMatthias Ringwald     sco_establishment_active->establish_audio_connection = 1;
553eddcd308SMatthias Ringwald     sco_establishment_active = 0;
554eddcd308SMatthias Ringwald }
555eddcd308SMatthias Ringwald 
556eddcd308SMatthias Ringwald 
557323d3000SMatthias Ringwald void hfp_handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){
5588a46ec40SMatthias Ringwald     UNUSED(channel);    // ok: no channel
5599ec2630cSMatthias Ringwald 
5603deb3ec6SMatthias Ringwald     bd_addr_t event_addr;
5613deb3ec6SMatthias Ringwald     uint16_t rfcomm_cid, handle;
562a0ffb263SMatthias Ringwald     hfp_connection_t * hfp_connection = NULL;
563674515e8SMatthias Ringwald     uint8_t status;
5643deb3ec6SMatthias Ringwald 
565a8500c8fSMatthias Ringwald     log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size);
566aa4dd815SMatthias Ringwald 
5670e2df43fSMatthias Ringwald     switch (hci_event_packet_get_type(packet)) {
568011577abSMilanka Ringwald         case HCI_EVENT_CONNECTION_REQUEST:
569011577abSMilanka Ringwald             // printf("hfp HCI_EVENT_CONNECTION_REQUEST\n");
5707522e673SMatthias Ringwald             switch(hci_event_connection_request_get_link_type(packet)){
5717522e673SMatthias Ringwald                 case 0: //  SCO
5727522e673SMatthias Ringwald                 case 2: // eSCO
573011577abSMilanka Ringwald                     hci_event_connection_request_get_bd_addr(packet, event_addr);
5747522e673SMatthias Ringwald                     hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr);
575011577abSMilanka Ringwald                     if (!hfp_connection) break;
576b72c4a9eSMatthias Ringwald                     hfp_connection->hf_accept_sco = 1;
577202c8a4cSMatthias Ringwald                     break;
5787522e673SMatthias Ringwald                 default:
5797522e673SMatthias Ringwald                     break;
5807522e673SMatthias Ringwald             }
581011577abSMilanka Ringwald             break;
5823deb3ec6SMatthias Ringwald 
5833deb3ec6SMatthias Ringwald         case RFCOMM_EVENT_INCOMING_CONNECTION:
5843deb3ec6SMatthias Ringwald             // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16)
585caa82391SMilanka Ringwald             rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr);
586323d3000SMatthias Ringwald             hfp_connection = provide_hfp_connection_context_for_bd_addr(event_addr, local_role);
587400b7c04SMatthias Ringwald             if (!hfp_connection){
588400b7c04SMatthias Ringwald                 log_info("hfp: no memory to accept incoming connection - decline");
589400b7c04SMatthias Ringwald                 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet));
590400b7c04SMatthias Ringwald                 return;
591400b7c04SMatthias Ringwald             }
592400b7c04SMatthias Ringwald             if (hfp_connection->state != HFP_IDLE) {
593400b7c04SMatthias Ringwald                 log_error("hfp: incoming connection but state != HFP_IDLE");
594400b7c04SMatthias Ringwald                 return;
595400b7c04SMatthias Ringwald             }
5963deb3ec6SMatthias Ringwald 
597caa82391SMilanka Ringwald             hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet);
598d63c37a1SMatthias Ringwald             hfp_connection->state = HFP_W4_RFCOMM_CONNECTED;
599674515e8SMatthias Ringwald             // printf("RFCOMM channel %u requested for %s\n", hfp_connection->rfcomm_cid, bd_addr_to_str(hfp_connection->remote_addr));
600d63c37a1SMatthias Ringwald             rfcomm_accept_connection(hfp_connection->rfcomm_cid);
6013deb3ec6SMatthias Ringwald             break;
6023deb3ec6SMatthias Ringwald 
603f8f6a918SMatthias Ringwald         case RFCOMM_EVENT_CHANNEL_OPENED:
6043deb3ec6SMatthias Ringwald             // data: event(8), len(8), status (8), address (48), handle(16), server channel(8), rfcomm_cid(16), max frame size(16)
605aa4dd815SMatthias Ringwald 
606674515e8SMatthias Ringwald             rfcomm_event_channel_opened_get_bd_addr(packet, event_addr);
607674515e8SMatthias Ringwald             status = rfcomm_event_channel_opened_get_status(packet);
608674515e8SMatthias Ringwald 
609d63c37a1SMatthias Ringwald             hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr);
610d63c37a1SMatthias Ringwald             if (!hfp_connection || hfp_connection->state != HFP_W4_RFCOMM_CONNECTED) return;
6113deb3ec6SMatthias Ringwald 
612674515e8SMatthias Ringwald             if (status) {
613*ca59be51SMatthias Ringwald                 hfp_emit_slc_connection_event(hfp_connection, status, rfcomm_event_channel_opened_get_con_handle(packet), event_addr);
614d63c37a1SMatthias Ringwald                 remove_hfp_connection_context(hfp_connection);
6153deb3ec6SMatthias Ringwald             } else {
616caa82391SMilanka Ringwald                 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet);
617caa82391SMilanka Ringwald                 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet);
6186a7f44bdSMilanka Ringwald                 bd_addr_copy(hfp_connection->remote_addr, event_addr);
619674515e8SMatthias Ringwald                 // uint16_t mtu = rfcomm_event_channel_opened_get_max_frame_size(packet);
620674515e8SMatthias Ringwald                 // printf("RFCOMM channel open succeeded. hfp_connection %p, RFCOMM Channel ID 0x%02x, max frame size %u\n", hfp_connection, hfp_connection->rfcomm_cid, mtu);
6213deb3ec6SMatthias Ringwald 
622d63c37a1SMatthias Ringwald                 switch (hfp_connection->state){
6233deb3ec6SMatthias Ringwald                     case HFP_W4_RFCOMM_CONNECTED:
624d63c37a1SMatthias Ringwald                         hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES;
6253deb3ec6SMatthias Ringwald                         break;
6263deb3ec6SMatthias Ringwald                     case HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN:
627d63c37a1SMatthias Ringwald                         hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM;
628674515e8SMatthias Ringwald                         // printf("Shutting down RFCOMM.\n");
6293deb3ec6SMatthias Ringwald                         break;
6303deb3ec6SMatthias Ringwald                     default:
6313deb3ec6SMatthias Ringwald                         break;
6323deb3ec6SMatthias Ringwald                 }
633bb6944afSMatthias Ringwald                 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid);
6343deb3ec6SMatthias Ringwald             }
6353deb3ec6SMatthias Ringwald             break;
6363deb3ec6SMatthias Ringwald 
637eddcd308SMatthias Ringwald         case HCI_EVENT_COMMAND_STATUS:
638eddcd308SMatthias Ringwald             if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) {
639be2a1a78SMatthias Ringwald                 status = hci_event_command_status_get_status(packet);
6406c5b2002SMatthias Ringwald                 if (status) {
641eddcd308SMatthias Ringwald                     hfp_handle_failed_sco_connection(hci_event_command_status_get_status(packet));
642eddcd308SMatthias Ringwald                }
6436c5b2002SMatthias Ringwald             }
644eddcd308SMatthias Ringwald             break;
645eddcd308SMatthias Ringwald 
6463deb3ec6SMatthias Ringwald         case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{
647011577abSMilanka Ringwald             hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr);
648011577abSMilanka Ringwald             hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr);
649011577abSMilanka Ringwald             if (!hfp_connection) {
650011577abSMilanka Ringwald                 log_error("HFP: connection does not exist for remote with addr %s.", bd_addr_to_str(event_addr));
651011577abSMilanka Ringwald                 return;
652011577abSMilanka Ringwald             }
653ce263fc8SMatthias Ringwald 
654011577abSMilanka Ringwald             status = hci_event_synchronous_connection_complete_get_status(packet);
655aa4dd815SMatthias Ringwald             if (status != 0){
656b72c4a9eSMatthias Ringwald                 hfp_connection->hf_accept_sco = 0;
657eddcd308SMatthias Ringwald                 hfp_handle_failed_sco_connection(status);
658aa4dd815SMatthias Ringwald                 break;
659aa4dd815SMatthias Ringwald             }
660aa4dd815SMatthias Ringwald 
661011577abSMilanka Ringwald             uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet);
662011577abSMilanka Ringwald             uint8_t  link_type = hci_event_synchronous_connection_complete_get_link_type(packet);
663011577abSMilanka Ringwald             uint8_t  transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet);  // measured in slots
664011577abSMilanka Ringwald             uint8_t  retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots
665011577abSMilanka Ringwald             uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes
666011577abSMilanka Ringwald             uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes
667011577abSMilanka Ringwald             uint8_t  air_mode = hci_event_synchronous_connection_complete_get_air_mode(packet);
6683deb3ec6SMatthias Ringwald 
6693deb3ec6SMatthias Ringwald             switch (link_type){
6703deb3ec6SMatthias Ringwald                 case 0x00:
671aa4dd815SMatthias Ringwald                     log_info("SCO Connection established.");
6723deb3ec6SMatthias Ringwald                     if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval);
6733deb3ec6SMatthias Ringwald                     if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval);
6743deb3ec6SMatthias Ringwald                     if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length);
6753deb3ec6SMatthias Ringwald                     if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length);
6763deb3ec6SMatthias Ringwald                     break;
6773deb3ec6SMatthias Ringwald                 case 0x02:
678aa4dd815SMatthias Ringwald                     log_info("eSCO Connection established. \n");
6793deb3ec6SMatthias Ringwald                     break;
6803deb3ec6SMatthias Ringwald                 default:
6813deb3ec6SMatthias Ringwald                     log_error("(e)SCO reserved link_type 0x%2x", link_type);
6823deb3ec6SMatthias Ringwald                     break;
6833deb3ec6SMatthias Ringwald             }
6843deb3ec6SMatthias Ringwald             log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, "
685aa4dd815SMatthias Ringwald                  " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle,
686aa4dd815SMatthias Ringwald                  bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, air_mode);
6873deb3ec6SMatthias Ringwald 
688d63c37a1SMatthias Ringwald             hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr);
6893deb3ec6SMatthias Ringwald 
690d63c37a1SMatthias Ringwald             if (!hfp_connection) {
691d63c37a1SMatthias Ringwald                 log_error("SCO link created, hfp_connection for address %s not found.", bd_addr_to_str(event_addr));
6923deb3ec6SMatthias Ringwald                 break;
6933deb3ec6SMatthias Ringwald             }
6943deb3ec6SMatthias Ringwald 
695d63c37a1SMatthias Ringwald             if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){
696aa4dd815SMatthias Ringwald                 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN");
697d63c37a1SMatthias Ringwald                 hfp_connection->state = HFP_W2_DISCONNECT_SCO;
698aa4dd815SMatthias Ringwald                 break;
699aa4dd815SMatthias Ringwald             }
700d63c37a1SMatthias Ringwald             hfp_connection->sco_handle = sco_handle;
701d63c37a1SMatthias Ringwald             hfp_connection->establish_audio_connection = 0;
702d63c37a1SMatthias Ringwald             hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED;
703*ca59be51SMatthias Ringwald             hfp_emit_sco_event(hfp_connection, packet[2], sco_handle, event_addr, hfp_connection->negotiated_codec);
7043deb3ec6SMatthias Ringwald             break;
7053deb3ec6SMatthias Ringwald         }
7063deb3ec6SMatthias Ringwald 
7073deb3ec6SMatthias Ringwald         case RFCOMM_EVENT_CHANNEL_CLOSED:
708f8fbdce0SMatthias Ringwald             rfcomm_cid = little_endian_read_16(packet,2);
709d63c37a1SMatthias Ringwald             hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid);
710d63c37a1SMatthias Ringwald             if (!hfp_connection) break;
711d63c37a1SMatthias Ringwald             if (hfp_connection->state == HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART){
712d63c37a1SMatthias Ringwald                 hfp_connection->state = HFP_IDLE;
713323d3000SMatthias Ringwald                 hfp_establish_service_level_connection(hfp_connection->remote_addr, hfp_connection->service_uuid, local_role);
7143deb3ec6SMatthias Ringwald                 break;
7153deb3ec6SMatthias Ringwald             }
7163deb3ec6SMatthias Ringwald 
717*ca59be51SMatthias Ringwald             hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0);
718d63c37a1SMatthias Ringwald             remove_hfp_connection_context(hfp_connection);
7193deb3ec6SMatthias Ringwald             break;
7203deb3ec6SMatthias Ringwald 
7213deb3ec6SMatthias Ringwald         case HCI_EVENT_DISCONNECTION_COMPLETE:
722f8fbdce0SMatthias Ringwald             handle = little_endian_read_16(packet,3);
723d63c37a1SMatthias Ringwald             hfp_connection = get_hfp_connection_context_for_sco_handle(handle);
724aa4dd815SMatthias Ringwald 
725d63c37a1SMatthias Ringwald             if (!hfp_connection) break;
726aa4dd815SMatthias Ringwald 
727d63c37a1SMatthias Ringwald             if (hfp_connection->state != HFP_W4_SCO_DISCONNECTED){
728aa4dd815SMatthias Ringwald                 log_info("Received gap disconnect in wrong hfp state");
729aa4dd815SMatthias Ringwald             }
730d63c37a1SMatthias Ringwald             log_info("Check SCO handle: incoming 0x%02x, hfp_connection 0x%02x\n", handle, hfp_connection->sco_handle);
731aa4dd815SMatthias Ringwald 
732d63c37a1SMatthias Ringwald             if (handle == hfp_connection->sco_handle){
733aa4dd815SMatthias Ringwald                 log_info("SCO disconnected, w2 disconnect RFCOMM\n");
734d63c37a1SMatthias Ringwald                 hfp_connection->sco_handle = 0;
735d63c37a1SMatthias Ringwald                 hfp_connection->release_audio_connection = 0;
736d63c37a1SMatthias Ringwald                 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED;
737*ca59be51SMatthias Ringwald                 hfp_emit_event(hfp_connection, HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED, 0);
7383deb3ec6SMatthias Ringwald                 break;
7393deb3ec6SMatthias Ringwald             }
7403deb3ec6SMatthias Ringwald             break;
7413deb3ec6SMatthias Ringwald 
742fc64f94aSMatthias Ringwald         default:
7433deb3ec6SMatthias Ringwald             break;
7443deb3ec6SMatthias Ringwald     }
7453deb3ec6SMatthias Ringwald }
7463deb3ec6SMatthias Ringwald 
747aa4dd815SMatthias Ringwald // translates command string into hfp_command_t CMD
748aa4dd815SMatthias Ringwald static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){
749aa4dd815SMatthias Ringwald     int offset = isHandsFree ? 0 : 2;
7503deb3ec6SMatthias Ringwald 
751ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_LIST_CURRENT_CALLS, strlen(HFP_LIST_CURRENT_CALLS)) == 0){
752ce263fc8SMatthias Ringwald         return HFP_CMD_LIST_CURRENT_CALLS;
753ce263fc8SMatthias Ringwald     }
754ce263fc8SMatthias Ringwald 
755ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_SUBSCRIBER_NUMBER_INFORMATION, strlen(HFP_SUBSCRIBER_NUMBER_INFORMATION)) == 0){
756ce263fc8SMatthias Ringwald         return HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION;
757ce263fc8SMatthias Ringwald     }
758ce263fc8SMatthias Ringwald 
759aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_PHONE_NUMBER_FOR_VOICE_TAG, strlen(HFP_PHONE_NUMBER_FOR_VOICE_TAG)) == 0){
760ce263fc8SMatthias Ringwald         if (isHandsFree) return HFP_CMD_AG_SENT_PHONE_NUMBER;
761aa4dd815SMatthias Ringwald         return HFP_CMD_HF_REQUEST_PHONE_NUMBER;
7623deb3ec6SMatthias Ringwald     }
7633deb3ec6SMatthias Ringwald 
764aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_TRANSMIT_DTMF_CODES, strlen(HFP_TRANSMIT_DTMF_CODES)) == 0){
765aa4dd815SMatthias Ringwald         return HFP_CMD_TRANSMIT_DTMF_CODES;
7663deb3ec6SMatthias Ringwald     }
7673deb3ec6SMatthias Ringwald 
768aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_SET_MICROPHONE_GAIN, strlen(HFP_SET_MICROPHONE_GAIN)) == 0){
769aa4dd815SMatthias Ringwald         return HFP_CMD_SET_MICROPHONE_GAIN;
7703deb3ec6SMatthias Ringwald     }
7713deb3ec6SMatthias Ringwald 
772aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_SET_SPEAKER_GAIN, strlen(HFP_SET_SPEAKER_GAIN)) == 0){
773aa4dd815SMatthias Ringwald         return HFP_CMD_SET_SPEAKER_GAIN;
7743deb3ec6SMatthias Ringwald     }
7753deb3ec6SMatthias Ringwald 
776aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_ACTIVATE_VOICE_RECOGNITION, strlen(HFP_ACTIVATE_VOICE_RECOGNITION)) == 0){
777aa4dd815SMatthias Ringwald         if (isHandsFree) return HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION;
778aa4dd815SMatthias Ringwald         return HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION;
7793deb3ec6SMatthias Ringwald     }
7803deb3ec6SMatthias Ringwald 
781aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_TURN_OFF_EC_AND_NR, strlen(HFP_TURN_OFF_EC_AND_NR)) == 0){
782aa4dd815SMatthias Ringwald         return HFP_CMD_TURN_OFF_EC_AND_NR;
7833deb3ec6SMatthias Ringwald     }
7843deb3ec6SMatthias Ringwald 
785aa4dd815SMatthias Ringwald     if (strncmp(line_buffer, HFP_CALL_ANSWERED, strlen(HFP_CALL_ANSWERED)) == 0){
786aa4dd815SMatthias Ringwald         return HFP_CMD_CALL_ANSWERED;
7873deb3ec6SMatthias Ringwald     }
7883deb3ec6SMatthias Ringwald 
789aa4dd815SMatthias Ringwald     if (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0){
790aa4dd815SMatthias Ringwald         return HFP_CMD_CALL_PHONE_NUMBER;
7913deb3ec6SMatthias Ringwald     }
7923deb3ec6SMatthias Ringwald 
793ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_REDIAL_LAST_NUMBER, strlen(HFP_REDIAL_LAST_NUMBER)) == 0){
794aa4dd815SMatthias Ringwald         return HFP_CMD_REDIAL_LAST_NUMBER;
7953deb3ec6SMatthias Ringwald     }
7963deb3ec6SMatthias Ringwald 
797aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_CHANGE_IN_BAND_RING_TONE_SETTING, strlen(HFP_CHANGE_IN_BAND_RING_TONE_SETTING)) == 0){
798aa4dd815SMatthias Ringwald         return HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING;
799aa4dd815SMatthias Ringwald     }
800aa4dd815SMatthias Ringwald 
801aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_HANG_UP_CALL, strlen(HFP_HANG_UP_CALL)) == 0){
802aa4dd815SMatthias Ringwald         return HFP_CMD_HANG_UP_CALL;
803aa4dd815SMatthias Ringwald     }
804aa4dd815SMatthias Ringwald 
805aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_ERROR, strlen(HFP_ERROR)) == 0){
806aa4dd815SMatthias Ringwald         return HFP_CMD_ERROR;
807aa4dd815SMatthias Ringwald     }
808aa4dd815SMatthias Ringwald 
809ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_RING, strlen(HFP_RING)) == 0){
810ce263fc8SMatthias Ringwald         return HFP_CMD_RING;
811ce263fc8SMatthias Ringwald     }
812ce263fc8SMatthias Ringwald 
813aa4dd815SMatthias Ringwald     if (isHandsFree && strncmp(line_buffer+offset, HFP_OK, strlen(HFP_OK)) == 0){
814aa4dd815SMatthias Ringwald         return HFP_CMD_OK;
815aa4dd815SMatthias Ringwald     }
816aa4dd815SMatthias Ringwald 
817aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_SUPPORTED_FEATURES, strlen(HFP_SUPPORTED_FEATURES)) == 0){
818aa4dd815SMatthias Ringwald         return HFP_CMD_SUPPORTED_FEATURES;
819aa4dd815SMatthias Ringwald     }
820aa4dd815SMatthias Ringwald 
821ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_TRANSFER_HF_INDICATOR_STATUS, strlen(HFP_TRANSFER_HF_INDICATOR_STATUS)) == 0){
822ce263fc8SMatthias Ringwald         return HFP_CMD_HF_INDICATOR_STATUS;
823ce263fc8SMatthias Ringwald     }
824ce263fc8SMatthias Ringwald 
825ce263fc8SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_RESPONSE_AND_HOLD, strlen(HFP_RESPONSE_AND_HOLD)) == 0){
826ce263fc8SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_RESPONSE_AND_HOLD)+offset, "?", 1) == 0){
827ce263fc8SMatthias Ringwald             return HFP_CMD_RESPONSE_AND_HOLD_QUERY;
828ce263fc8SMatthias Ringwald         }
829ce263fc8SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_RESPONSE_AND_HOLD)+offset, "=", 1) == 0){
830ce263fc8SMatthias Ringwald             return HFP_CMD_RESPONSE_AND_HOLD_COMMAND;
831ce263fc8SMatthias Ringwald         }
832667ec068SMatthias Ringwald         return HFP_CMD_RESPONSE_AND_HOLD_STATUS;
833ce263fc8SMatthias Ringwald     }
834ce263fc8SMatthias Ringwald 
835aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_INDICATOR, strlen(HFP_INDICATOR)) == 0){
836aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_INDICATOR)+offset, "?", 1) == 0){
837aa4dd815SMatthias Ringwald             return HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS;
838aa4dd815SMatthias Ringwald         }
839aa4dd815SMatthias Ringwald 
840aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_INDICATOR)+offset, "=?", 2) == 0){
841aa4dd815SMatthias Ringwald             return HFP_CMD_RETRIEVE_AG_INDICATORS;
842aa4dd815SMatthias Ringwald         }
843aa4dd815SMatthias Ringwald     }
844aa4dd815SMatthias Ringwald 
845aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_AVAILABLE_CODECS, strlen(HFP_AVAILABLE_CODECS)) == 0){
846aa4dd815SMatthias Ringwald         return HFP_CMD_AVAILABLE_CODECS;
847aa4dd815SMatthias Ringwald     }
848aa4dd815SMatthias Ringwald 
849aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_ENABLE_STATUS_UPDATE_FOR_AG_INDICATORS, strlen(HFP_ENABLE_STATUS_UPDATE_FOR_AG_INDICATORS)) == 0){
850aa4dd815SMatthias Ringwald         return HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE;
851aa4dd815SMatthias Ringwald     }
852aa4dd815SMatthias Ringwald 
853aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_ENABLE_CLIP, strlen(HFP_ENABLE_CLIP)) == 0){
854a0ffb263SMatthias Ringwald         if (isHandsFree) return HFP_CMD_AG_SENT_CLIP_INFORMATION;
855aa4dd815SMatthias Ringwald         return HFP_CMD_ENABLE_CLIP;
856aa4dd815SMatthias Ringwald     }
857aa4dd815SMatthias Ringwald 
858aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_ENABLE_CALL_WAITING_NOTIFICATION, strlen(HFP_ENABLE_CALL_WAITING_NOTIFICATION)) == 0){
859a0ffb263SMatthias Ringwald         if (isHandsFree) return HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE;
860aa4dd815SMatthias Ringwald         return HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION;
861aa4dd815SMatthias Ringwald     }
862aa4dd815SMatthias Ringwald 
863aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES, strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)) == 0){
864aa4dd815SMatthias Ringwald 
865aa4dd815SMatthias Ringwald         if (isHandsFree) return HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES;
866aa4dd815SMatthias Ringwald 
867aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)+offset, "=?", 2) == 0){
868aa4dd815SMatthias Ringwald             return HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES;
869aa4dd815SMatthias Ringwald         }
870667ec068SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES)+offset, "=", 1) == 0){
871aa4dd815SMatthias Ringwald             return HFP_CMD_CALL_HOLD;
872aa4dd815SMatthias Ringwald         }
873aa4dd815SMatthias Ringwald 
874aa4dd815SMatthias Ringwald         return HFP_CMD_UNKNOWN;
875aa4dd815SMatthias Ringwald     }
876aa4dd815SMatthias Ringwald 
877aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_GENERIC_STATUS_INDICATOR, strlen(HFP_GENERIC_STATUS_INDICATOR)) == 0){
878667ec068SMatthias Ringwald         if (isHandsFree) {
879667ec068SMatthias Ringwald             return HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS;
880667ec068SMatthias Ringwald         }
881aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_GENERIC_STATUS_INDICATOR)+offset, "=?", 2) == 0){
882aa4dd815SMatthias Ringwald             return HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS;
883aa4dd815SMatthias Ringwald         }
884aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_GENERIC_STATUS_INDICATOR)+offset, "=", 1) == 0){
885aa4dd815SMatthias Ringwald             return HFP_CMD_LIST_GENERIC_STATUS_INDICATORS;
886aa4dd815SMatthias Ringwald         }
887aa4dd815SMatthias Ringwald         return HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE;
888aa4dd815SMatthias Ringwald     }
889aa4dd815SMatthias Ringwald 
890aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_UPDATE_ENABLE_STATUS_FOR_INDIVIDUAL_AG_INDICATORS, strlen(HFP_UPDATE_ENABLE_STATUS_FOR_INDIVIDUAL_AG_INDICATORS)) == 0){
891aa4dd815SMatthias Ringwald         return HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE;
8923deb3ec6SMatthias Ringwald     }
8933deb3ec6SMatthias Ringwald 
8943deb3ec6SMatthias Ringwald 
895aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_QUERY_OPERATOR_SELECTION, strlen(HFP_QUERY_OPERATOR_SELECTION)) == 0){
896aa4dd815SMatthias Ringwald         if (strncmp(line_buffer+strlen(HFP_QUERY_OPERATOR_SELECTION)+offset, "=", 1) == 0){
897aa4dd815SMatthias Ringwald             return HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT;
8983deb3ec6SMatthias Ringwald         }
899aa4dd815SMatthias Ringwald         return HFP_CMD_QUERY_OPERATOR_SELECTION_NAME;
9003deb3ec6SMatthias Ringwald     }
9013deb3ec6SMatthias Ringwald 
902aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_TRANSFER_AG_INDICATOR_STATUS, strlen(HFP_TRANSFER_AG_INDICATOR_STATUS)) == 0){
903aa4dd815SMatthias Ringwald         return HFP_CMD_TRANSFER_AG_INDICATOR_STATUS;
9043deb3ec6SMatthias Ringwald     }
9053deb3ec6SMatthias Ringwald 
906aa4dd815SMatthias Ringwald     if (isHandsFree && strncmp(line_buffer+offset, HFP_EXTENDED_AUDIO_GATEWAY_ERROR, strlen(HFP_EXTENDED_AUDIO_GATEWAY_ERROR)) == 0){
907aa4dd815SMatthias Ringwald         return HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR;
9083deb3ec6SMatthias Ringwald     }
9093deb3ec6SMatthias Ringwald 
910aa4dd815SMatthias Ringwald     if (!isHandsFree && strncmp(line_buffer+offset, HFP_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR, strlen(HFP_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR)) == 0){
911aa4dd815SMatthias Ringwald         return HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR;
9123deb3ec6SMatthias Ringwald     }
9133deb3ec6SMatthias Ringwald 
914aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_TRIGGER_CODEC_CONNECTION_SETUP, strlen(HFP_TRIGGER_CODEC_CONNECTION_SETUP)) == 0){
915aa4dd815SMatthias Ringwald         return HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP;
916aa4dd815SMatthias Ringwald     }
917aa4dd815SMatthias Ringwald 
918aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, HFP_CONFIRM_COMMON_CODEC, strlen(HFP_CONFIRM_COMMON_CODEC)) == 0){
9193deb3ec6SMatthias Ringwald         if (isHandsFree){
920aa4dd815SMatthias Ringwald             return HFP_CMD_AG_SUGGESTED_CODEC;
9213deb3ec6SMatthias Ringwald         } else {
922aa4dd815SMatthias Ringwald             return HFP_CMD_HF_CONFIRMED_CODEC;
9233deb3ec6SMatthias Ringwald         }
9243deb3ec6SMatthias Ringwald     }
9253deb3ec6SMatthias Ringwald 
926aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, "AT+", 3) == 0){
927667ec068SMatthias Ringwald         log_info("process unknown HF command %s \n", line_buffer);
928aa4dd815SMatthias Ringwald         return HFP_CMD_UNKNOWN;
9293deb3ec6SMatthias Ringwald     }
9303deb3ec6SMatthias Ringwald 
931aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, "+", 1) == 0){
932667ec068SMatthias Ringwald         log_info(" process unknown AG command %s \n", line_buffer);
933aa4dd815SMatthias Ringwald         return HFP_CMD_UNKNOWN;
934aa4dd815SMatthias Ringwald     }
9353deb3ec6SMatthias Ringwald 
936aa4dd815SMatthias Ringwald     if (strncmp(line_buffer+offset, "NOP", 3) == 0){
937aa4dd815SMatthias Ringwald         return HFP_CMD_NONE;
938aa4dd815SMatthias Ringwald     }
939aa4dd815SMatthias Ringwald 
940aa4dd815SMatthias Ringwald     return HFP_CMD_NONE;
9413deb3ec6SMatthias Ringwald }
9423deb3ec6SMatthias Ringwald 
943a0ffb263SMatthias Ringwald static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){
944ce263fc8SMatthias Ringwald     // printf("hfp_parser_store_byte %c at pos %u\n", (char) byte, context->line_size);
9453deb3ec6SMatthias Ringwald     // TODO: add limit
946a0ffb263SMatthias Ringwald     hfp_connection->line_buffer[hfp_connection->line_size++] = byte;
947a0ffb263SMatthias Ringwald     hfp_connection->line_buffer[hfp_connection->line_size] = 0;
9483deb3ec6SMatthias Ringwald }
949a0ffb263SMatthias Ringwald static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){
950a0ffb263SMatthias Ringwald     return hfp_connection->line_size == 0;
9513deb3ec6SMatthias Ringwald }
9523deb3ec6SMatthias Ringwald 
9533deb3ec6SMatthias Ringwald static int hfp_parser_is_end_of_line(uint8_t byte){
9543deb3ec6SMatthias Ringwald     return byte == '\n' || byte == '\r';
9553deb3ec6SMatthias Ringwald }
9563deb3ec6SMatthias Ringwald 
9573deb3ec6SMatthias Ringwald static int hfp_parser_is_end_of_header(uint8_t byte){
9583deb3ec6SMatthias Ringwald     return hfp_parser_is_end_of_line(byte) || byte == ':' || byte == '?';
9593deb3ec6SMatthias Ringwald }
9603deb3ec6SMatthias Ringwald 
961a0ffb263SMatthias Ringwald static int hfp_parser_found_separator(hfp_connection_t * hfp_connection, uint8_t byte){
962a0ffb263SMatthias Ringwald     if (hfp_connection->keep_byte == 1) return 1;
9633deb3ec6SMatthias Ringwald 
9643deb3ec6SMatthias Ringwald     int found_separator =   byte == ',' || byte == '\n'|| byte == '\r'||
9653deb3ec6SMatthias Ringwald                             byte == ')' || byte == '(' || byte == ':' ||
9663deb3ec6SMatthias Ringwald                             byte == '-' || byte == '"' ||  byte == '?'|| byte == '=';
9673deb3ec6SMatthias Ringwald     return found_separator;
9683deb3ec6SMatthias Ringwald }
9693deb3ec6SMatthias Ringwald 
970a0ffb263SMatthias Ringwald static void hfp_parser_next_state(hfp_connection_t * hfp_connection, uint8_t byte){
971a0ffb263SMatthias Ringwald     hfp_connection->line_size = 0;
9723deb3ec6SMatthias Ringwald     if (hfp_parser_is_end_of_line(byte)){
973a0ffb263SMatthias Ringwald         hfp_connection->parser_item_index = 0;
974a0ffb263SMatthias Ringwald         hfp_connection->parser_state = HFP_PARSER_CMD_HEADER;
9753deb3ec6SMatthias Ringwald         return;
9763deb3ec6SMatthias Ringwald     }
977a0ffb263SMatthias Ringwald     switch (hfp_connection->parser_state){
9783deb3ec6SMatthias Ringwald         case HFP_PARSER_CMD_HEADER:
979a0ffb263SMatthias Ringwald             hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE;
980a0ffb263SMatthias Ringwald             if (hfp_connection->keep_byte == 1){
981a0ffb263SMatthias Ringwald                 hfp_parser_store_byte(hfp_connection, byte);
982a0ffb263SMatthias Ringwald                 hfp_connection->keep_byte = 0;
9833deb3ec6SMatthias Ringwald             }
9843deb3ec6SMatthias Ringwald             break;
9853deb3ec6SMatthias Ringwald         case HFP_PARSER_CMD_SEQUENCE:
986a0ffb263SMatthias Ringwald             switch (hfp_connection->command){
987ce263fc8SMatthias Ringwald                 case HFP_CMD_AG_SENT_PHONE_NUMBER:
988a0ffb263SMatthias Ringwald                 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE:
989a0ffb263SMatthias Ringwald                 case HFP_CMD_AG_SENT_CLIP_INFORMATION:
9903deb3ec6SMatthias Ringwald                 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS:
991aa4dd815SMatthias Ringwald                 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME:
992aa4dd815SMatthias Ringwald                 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT:
993aa4dd815SMatthias Ringwald                 case HFP_CMD_RETRIEVE_AG_INDICATORS:
994aa4dd815SMatthias Ringwald                 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE:
995ce263fc8SMatthias Ringwald                 case HFP_CMD_HF_INDICATOR_STATUS:
996a0ffb263SMatthias Ringwald                     hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM;
9973deb3ec6SMatthias Ringwald                     break;
9983deb3ec6SMatthias Ringwald                 default:
9993deb3ec6SMatthias Ringwald                     break;
10003deb3ec6SMatthias Ringwald             }
10013deb3ec6SMatthias Ringwald             break;
10023deb3ec6SMatthias Ringwald         case HFP_PARSER_SECOND_ITEM:
1003a0ffb263SMatthias Ringwald             hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM;
10043deb3ec6SMatthias Ringwald             break;
10053deb3ec6SMatthias Ringwald         case HFP_PARSER_THIRD_ITEM:
1006a0ffb263SMatthias Ringwald             if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){
1007a0ffb263SMatthias Ringwald                 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE;
10083deb3ec6SMatthias Ringwald                 break;
10093deb3ec6SMatthias Ringwald             }
1010a0ffb263SMatthias Ringwald             hfp_connection->parser_state = HFP_PARSER_CMD_HEADER;
10113deb3ec6SMatthias Ringwald             break;
10123deb3ec6SMatthias Ringwald     }
10133deb3ec6SMatthias Ringwald }
10143deb3ec6SMatthias Ringwald 
1015a0ffb263SMatthias Ringwald void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){
1016aa4dd815SMatthias Ringwald     // handle ATD<dial_string>;
1017a0ffb263SMatthias Ringwald     if (strncmp((const char*)hfp_connection->line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0){
1018aa4dd815SMatthias Ringwald         // check for end-of-line or ';'
1019aa4dd815SMatthias Ringwald         if (byte == ';' || hfp_parser_is_end_of_line(byte)){
1020a0ffb263SMatthias Ringwald             hfp_connection->line_buffer[hfp_connection->line_size] = 0;
1021a0ffb263SMatthias Ringwald             hfp_connection->line_size = 0;
1022a0ffb263SMatthias Ringwald             hfp_connection->command = HFP_CMD_CALL_PHONE_NUMBER;
1023aa4dd815SMatthias Ringwald         } else {
1024a0ffb263SMatthias Ringwald             hfp_connection->line_buffer[hfp_connection->line_size++] = byte;
1025aa4dd815SMatthias Ringwald         }
1026aa4dd815SMatthias Ringwald         return;
1027aa4dd815SMatthias Ringwald     }
1028aa4dd815SMatthias Ringwald 
10293deb3ec6SMatthias Ringwald     // TODO: handle space inside word
1030a0ffb263SMatthias Ringwald     if (byte == ' ' && hfp_connection->parser_state > HFP_PARSER_CMD_HEADER) return;
10313deb3ec6SMatthias Ringwald 
1032a0ffb263SMatthias Ringwald     if (byte == ',' && hfp_connection->command == HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE){
1033a0ffb263SMatthias Ringwald         if (hfp_connection->line_size == 0){
1034a0ffb263SMatthias Ringwald             hfp_connection->line_buffer[0] = 0;
1035a0ffb263SMatthias Ringwald             hfp_connection->ignore_value = 1;
1036a0ffb263SMatthias Ringwald             parse_sequence(hfp_connection);
1037ce263fc8SMatthias Ringwald             return;
1038ce263fc8SMatthias Ringwald         }
1039ce263fc8SMatthias Ringwald     }
1040ce263fc8SMatthias Ringwald 
1041a0ffb263SMatthias Ringwald     if (!hfp_parser_found_separator(hfp_connection, byte)){
1042a0ffb263SMatthias Ringwald         hfp_parser_store_byte(hfp_connection, byte);
10433deb3ec6SMatthias Ringwald         return;
10443deb3ec6SMatthias Ringwald     }
1045ce263fc8SMatthias Ringwald 
10463deb3ec6SMatthias Ringwald     if (hfp_parser_is_end_of_line(byte)) {
1047a0ffb263SMatthias Ringwald         if (hfp_parser_is_buffer_empty(hfp_connection)){
1048a0ffb263SMatthias Ringwald             hfp_connection->parser_state = HFP_PARSER_CMD_HEADER;
10493deb3ec6SMatthias Ringwald         }
10503deb3ec6SMatthias Ringwald     }
1051a0ffb263SMatthias Ringwald     if (hfp_parser_is_buffer_empty(hfp_connection)) return;
10523deb3ec6SMatthias Ringwald 
1053a0ffb263SMatthias Ringwald     switch (hfp_connection->parser_state){
10543deb3ec6SMatthias Ringwald         case HFP_PARSER_CMD_HEADER: // header
10553deb3ec6SMatthias Ringwald             if (byte == '='){
1056a0ffb263SMatthias Ringwald                 hfp_connection->keep_byte = 1;
1057a0ffb263SMatthias Ringwald                 hfp_parser_store_byte(hfp_connection, byte);
10583deb3ec6SMatthias Ringwald                 return;
10593deb3ec6SMatthias Ringwald             }
10603deb3ec6SMatthias Ringwald 
10613deb3ec6SMatthias Ringwald             if (byte == '?'){
1062a0ffb263SMatthias Ringwald                 hfp_connection->keep_byte = 0;
1063a0ffb263SMatthias Ringwald                 hfp_parser_store_byte(hfp_connection, byte);
10643deb3ec6SMatthias Ringwald                 return;
10653deb3ec6SMatthias Ringwald             }
1066ce263fc8SMatthias Ringwald 
1067ce263fc8SMatthias Ringwald             if (byte == ','){
1068a0ffb263SMatthias Ringwald                 hfp_connection->resolve_byte = 1;
1069ce263fc8SMatthias Ringwald             }
1070ce263fc8SMatthias Ringwald 
1071a0ffb263SMatthias Ringwald             // printf(" parse header 2 %s, keep separator $ %d\n", hfp_connection->line_buffer, hfp_connection->keep_byte);
1072a0ffb263SMatthias Ringwald             if (hfp_parser_is_end_of_header(byte) || hfp_connection->keep_byte == 1){
1073a0ffb263SMatthias Ringwald                 // printf(" parse header 3 %s, keep separator $ %d\n", hfp_connection->line_buffer, hfp_connection->keep_byte);
1074a0ffb263SMatthias Ringwald                 char * line_buffer = (char *)hfp_connection->line_buffer;
1075a0ffb263SMatthias Ringwald                 hfp_connection->command = parse_command(line_buffer, isHandsFree);
1076aa4dd815SMatthias Ringwald 
1077a0ffb263SMatthias Ringwald                 /* resolve command name according to hfp_connection */
1078a0ffb263SMatthias Ringwald                 if (hfp_connection->command == HFP_CMD_UNKNOWN){
1079a0ffb263SMatthias Ringwald                     switch(hfp_connection->state){
1080aa4dd815SMatthias Ringwald                         case HFP_W4_LIST_GENERIC_STATUS_INDICATORS:
1081a0ffb263SMatthias Ringwald                             hfp_connection->command = HFP_CMD_LIST_GENERIC_STATUS_INDICATORS;
1082aa4dd815SMatthias Ringwald                             break;
1083aa4dd815SMatthias Ringwald                         case HFP_W4_RETRIEVE_GENERIC_STATUS_INDICATORS:
1084a0ffb263SMatthias Ringwald                             hfp_connection->command = HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS;
1085aa4dd815SMatthias Ringwald                             break;
1086aa4dd815SMatthias Ringwald                         case HFP_W4_RETRIEVE_INITITAL_STATE_GENERIC_STATUS_INDICATORS:
1087a0ffb263SMatthias Ringwald                             hfp_connection->command = HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE;
1088aa4dd815SMatthias Ringwald                             break;
1089aa4dd815SMatthias Ringwald                         case HFP_W4_RETRIEVE_INDICATORS_STATUS:
1090a0ffb263SMatthias Ringwald                             hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS;
1091aa4dd815SMatthias Ringwald                             break;
1092aa4dd815SMatthias Ringwald                         case HFP_W4_RETRIEVE_INDICATORS:
1093a0ffb263SMatthias Ringwald                             hfp_connection->send_ag_indicators_segment = 0;
1094a0ffb263SMatthias Ringwald                             hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS;
1095aa4dd815SMatthias Ringwald                             break;
1096aa4dd815SMatthias Ringwald                         default:
1097aa4dd815SMatthias Ringwald                             break;
1098aa4dd815SMatthias Ringwald                     }
1099aa4dd815SMatthias Ringwald                 }
11003deb3ec6SMatthias Ringwald             }
11013deb3ec6SMatthias Ringwald             break;
11023deb3ec6SMatthias Ringwald 
1103ce263fc8SMatthias Ringwald         case HFP_PARSER_CMD_SEQUENCE:
1104a0ffb263SMatthias Ringwald             parse_sequence(hfp_connection);
1105ce263fc8SMatthias Ringwald             break;
1106ce263fc8SMatthias Ringwald         case HFP_PARSER_SECOND_ITEM:
1107a0ffb263SMatthias Ringwald             switch (hfp_connection->command){
1108ce263fc8SMatthias Ringwald                 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME:
1109a0ffb263SMatthias Ringwald                     log_info("format %s, ", hfp_connection->line_buffer);
11102308e108SMilanka Ringwald                     hfp_connection->network_operator.format =  btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1111ce263fc8SMatthias Ringwald                     break;
1112ce263fc8SMatthias Ringwald                 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT:
1113a0ffb263SMatthias Ringwald                     log_info("format %s \n", hfp_connection->line_buffer);
11142308e108SMilanka Ringwald                     hfp_connection->network_operator.format =  btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1115ce263fc8SMatthias Ringwald                     break;
1116ce263fc8SMatthias Ringwald                 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS:
1117ce263fc8SMatthias Ringwald                 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS:
1118ce263fc8SMatthias Ringwald                 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE:
11192308e108SMilanka Ringwald                     hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
1120ce263fc8SMatthias Ringwald                     break;
1121ce263fc8SMatthias Ringwald                 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS:
11222308e108SMilanka Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
1123a0ffb263SMatthias Ringwald                     log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status);
1124a0ffb263SMatthias Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1;
1125ce263fc8SMatthias Ringwald                     break;
1126ce263fc8SMatthias Ringwald                 case HFP_CMD_RETRIEVE_AG_INDICATORS:
11272308e108SMilanka Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer);
1128a0ffb263SMatthias Ringwald                     log_info("%s, ", hfp_connection->line_buffer);
1129ce263fc8SMatthias Ringwald                     break;
1130ce263fc8SMatthias Ringwald                 case HFP_CMD_AG_SENT_PHONE_NUMBER:
1131a0ffb263SMatthias Ringwald                 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE:
1132a0ffb263SMatthias Ringwald                 case HFP_CMD_AG_SENT_CLIP_INFORMATION:
11332308e108SMilanka Ringwald                     hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
1134ce263fc8SMatthias Ringwald                     break;
1135ce263fc8SMatthias Ringwald                 default:
1136ce263fc8SMatthias Ringwald                     break;
1137ce263fc8SMatthias Ringwald             }
1138ce263fc8SMatthias Ringwald             break;
1139ce263fc8SMatthias Ringwald 
1140ce263fc8SMatthias Ringwald         case HFP_PARSER_THIRD_ITEM:
1141a0ffb263SMatthias Ringwald              switch (hfp_connection->command){
1142ce263fc8SMatthias Ringwald                 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME:
114389425bfcSMilanka Ringwald                     strncpy(hfp_connection->network_operator.name, (char *)hfp_connection->line_buffer, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE);
114489425bfcSMilanka Ringwald                     hfp_connection->network_operator.name[HFP_MAX_NETWORK_OPERATOR_NAME_SIZE - 1] = 0;
1145a0ffb263SMatthias Ringwald                     log_info("name %s\n", hfp_connection->line_buffer);
1146ce263fc8SMatthias Ringwald                     break;
1147ce263fc8SMatthias Ringwald                 case HFP_CMD_RETRIEVE_AG_INDICATORS:
11482308e108SMilanka Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer);
1149a0ffb263SMatthias Ringwald                     hfp_connection->parser_item_index++;
1150a0ffb263SMatthias Ringwald                     hfp_connection->ag_indicators_nr = hfp_connection->parser_item_index;
1151a0ffb263SMatthias Ringwald                     log_info("%s)\n", hfp_connection->line_buffer);
1152ce263fc8SMatthias Ringwald                     break;
1153ce263fc8SMatthias Ringwald                 default:
1154ce263fc8SMatthias Ringwald                     break;
1155ce263fc8SMatthias Ringwald             }
1156ce263fc8SMatthias Ringwald             break;
1157ce263fc8SMatthias Ringwald     }
1158a0ffb263SMatthias Ringwald     hfp_parser_next_state(hfp_connection, byte);
1159ce263fc8SMatthias Ringwald 
1160a0ffb263SMatthias Ringwald     if (hfp_connection->resolve_byte && hfp_connection->command == HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE){
1161a0ffb263SMatthias Ringwald         hfp_connection->resolve_byte = 0;
1162a0ffb263SMatthias Ringwald         hfp_connection->ignore_value = 1;
1163a0ffb263SMatthias Ringwald         parse_sequence(hfp_connection);
1164a0ffb263SMatthias Ringwald         hfp_connection->line_buffer[0] = 0;
1165a0ffb263SMatthias Ringwald         hfp_connection->line_size = 0;
1166ce263fc8SMatthias Ringwald     }
1167ce263fc8SMatthias Ringwald }
1168ce263fc8SMatthias Ringwald 
1169a0ffb263SMatthias Ringwald static void parse_sequence(hfp_connection_t * hfp_connection){
1170ce263fc8SMatthias Ringwald     int value;
1171a0ffb263SMatthias Ringwald     switch (hfp_connection->command){
1172667ec068SMatthias Ringwald         case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS:
11732308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1174667ec068SMatthias Ringwald             int i;
1175a0ffb263SMatthias Ringwald             switch (hfp_connection->parser_item_index){
1176667ec068SMatthias Ringwald                 case 0:
1177a0ffb263SMatthias Ringwald                     for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){
1178a0ffb263SMatthias Ringwald                         if (hfp_connection->generic_status_indicators[i].uuid == value){
1179a0ffb263SMatthias Ringwald                             hfp_connection->parser_indicator_index = i;
1180667ec068SMatthias Ringwald                             break;
1181667ec068SMatthias Ringwald                         }
1182667ec068SMatthias Ringwald                     }
1183667ec068SMatthias Ringwald                     break;
1184667ec068SMatthias Ringwald                 case 1:
1185a0ffb263SMatthias Ringwald                     if (hfp_connection->parser_indicator_index <0) break;
1186a0ffb263SMatthias Ringwald                     hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value;
1187667ec068SMatthias Ringwald                     log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n",
1188a0ffb263SMatthias Ringwald                      hfp_connection->parser_item_index, value);
1189667ec068SMatthias Ringwald                     break;
1190667ec068SMatthias Ringwald                 default:
1191667ec068SMatthias Ringwald                     break;
1192667ec068SMatthias Ringwald             }
1193a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1194667ec068SMatthias Ringwald             break;
1195667ec068SMatthias Ringwald 
1196667ec068SMatthias Ringwald         case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION:
1197a0ffb263SMatthias Ringwald             switch(hfp_connection->parser_item_index){
1198667ec068SMatthias Ringwald                 case 0:
1199a0ffb263SMatthias Ringwald                     strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number));
1200a0ffb263SMatthias Ringwald                     hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0;
1201667ec068SMatthias Ringwald                     break;
1202667ec068SMatthias Ringwald                 case 1:
12032308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1204a0ffb263SMatthias Ringwald                     hfp_connection->bnip_type = value;
1205667ec068SMatthias Ringwald                     break;
1206667ec068SMatthias Ringwald                 default:
1207667ec068SMatthias Ringwald                     break;
1208667ec068SMatthias Ringwald             }
1209a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1210667ec068SMatthias Ringwald             break;
1211667ec068SMatthias Ringwald         case HFP_CMD_LIST_CURRENT_CALLS:
1212a0ffb263SMatthias Ringwald             switch(hfp_connection->parser_item_index){
1213667ec068SMatthias Ringwald                 case 0:
12142308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1215a0ffb263SMatthias Ringwald                     hfp_connection->clcc_idx = value;
1216667ec068SMatthias Ringwald                     break;
1217667ec068SMatthias Ringwald                 case 1:
12182308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1219a0ffb263SMatthias Ringwald                     hfp_connection->clcc_dir = value;
1220667ec068SMatthias Ringwald                     break;
1221667ec068SMatthias Ringwald                 case 2:
12222308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1223a0ffb263SMatthias Ringwald                     hfp_connection->clcc_status = value;
1224667ec068SMatthias Ringwald                     break;
1225667ec068SMatthias Ringwald                 case 3:
12262308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1227a0ffb263SMatthias Ringwald                     hfp_connection->clcc_mpty = value;
1228667ec068SMatthias Ringwald                     break;
1229667ec068SMatthias Ringwald                 case 4:
1230a0ffb263SMatthias Ringwald                     strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number));
1231a0ffb263SMatthias Ringwald                     hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0;
1232667ec068SMatthias Ringwald                     break;
1233667ec068SMatthias Ringwald                 case 5:
12342308e108SMilanka Ringwald                     value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1235a0ffb263SMatthias Ringwald                     hfp_connection->bnip_type = value;
1236667ec068SMatthias Ringwald                     break;
1237667ec068SMatthias Ringwald                 default:
1238667ec068SMatthias Ringwald                     break;
1239667ec068SMatthias Ringwald             }
1240a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1241667ec068SMatthias Ringwald             break;
1242aa4dd815SMatthias Ringwald         case HFP_CMD_SET_MICROPHONE_GAIN:
12432308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1244a0ffb263SMatthias Ringwald             hfp_connection->microphone_gain = value;
1245aa4dd815SMatthias Ringwald             log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value);
1246aa4dd815SMatthias Ringwald             break;
1247aa4dd815SMatthias Ringwald         case HFP_CMD_SET_SPEAKER_GAIN:
12482308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1249a0ffb263SMatthias Ringwald             hfp_connection->speaker_gain = value;
1250aa4dd815SMatthias Ringwald             log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value);
1251aa4dd815SMatthias Ringwald             break;
1252aa4dd815SMatthias Ringwald         case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION:
12532308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1254a0ffb263SMatthias Ringwald             hfp_connection->ag_activate_voice_recognition = value;
1255aa4dd815SMatthias Ringwald             log_info("hfp parse HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION %d\n", value);
1256aa4dd815SMatthias Ringwald             break;
1257aa4dd815SMatthias Ringwald         case HFP_CMD_TURN_OFF_EC_AND_NR:
12582308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1259a0ffb263SMatthias Ringwald             hfp_connection->ag_echo_and_noise_reduction = value;
1260aa4dd815SMatthias Ringwald             log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value);
1261aa4dd815SMatthias Ringwald             break;
1262aa4dd815SMatthias Ringwald         case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING:
12632308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1264a0ffb263SMatthias Ringwald             hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value);
1265aa4dd815SMatthias Ringwald             log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value);
1266aa4dd815SMatthias Ringwald             break;
12673deb3ec6SMatthias Ringwald         case HFP_CMD_HF_CONFIRMED_CODEC:
12682308e108SMilanka Ringwald             hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer);
1269a0ffb263SMatthias Ringwald             log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed);
12703deb3ec6SMatthias Ringwald             break;
12713deb3ec6SMatthias Ringwald         case HFP_CMD_AG_SUGGESTED_CODEC:
12722308e108SMilanka Ringwald             hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer);
1273a0ffb263SMatthias Ringwald             log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec);
12743deb3ec6SMatthias Ringwald             break;
12753deb3ec6SMatthias Ringwald         case HFP_CMD_SUPPORTED_FEATURES:
12762308e108SMilanka Ringwald             hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer);
1277bace42efSMatthias Ringwald             log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features);
12783deb3ec6SMatthias Ringwald             break;
12793deb3ec6SMatthias Ringwald         case HFP_CMD_AVAILABLE_CODECS:
1280a0ffb263SMatthias Ringwald             log_info("Parsed codec %s\n", hfp_connection->line_buffer);
12812308e108SMilanka Ringwald             hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer);
1282a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1283a0ffb263SMatthias Ringwald             hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index;
12843deb3ec6SMatthias Ringwald             break;
1285aa4dd815SMatthias Ringwald         case HFP_CMD_RETRIEVE_AG_INDICATORS:
128689425bfcSMilanka Ringwald             strncpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name,  (char *)hfp_connection->line_buffer, HFP_MAX_INDICATOR_DESC_SIZE);
128789425bfcSMilanka Ringwald             hfp_connection->ag_indicators[hfp_connection->parser_item_index].name[HFP_MAX_INDICATOR_DESC_SIZE-1] = 0;
1288a0ffb263SMatthias Ringwald             hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1;
1289a0ffb263SMatthias Ringwald             log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer);
1290aa4dd815SMatthias Ringwald             break;
1291aa4dd815SMatthias Ringwald         case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS:
1292a0ffb263SMatthias Ringwald             log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer);
12932308e108SMilanka Ringwald             hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer);
1294a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
12953deb3ec6SMatthias Ringwald             break;
12963deb3ec6SMatthias Ringwald         case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE:
1297a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1298a0ffb263SMatthias Ringwald             if (hfp_connection->parser_item_index != 4) break;
1299a0ffb263SMatthias Ringwald             log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer);
13002308e108SMilanka Ringwald             value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1301a0ffb263SMatthias Ringwald             hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value;
13023deb3ec6SMatthias Ringwald             break;
13033deb3ec6SMatthias Ringwald         case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES:
1304a0ffb263SMatthias Ringwald             log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer);
1305a0ffb263SMatthias Ringwald             if (hfp_connection->line_size > 2 ) break;
130689425bfcSMilanka Ringwald             strncpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE);
130789425bfcSMilanka Ringwald             hfp_connection->remote_call_services[hfp_connection->remote_call_services_nr].name[HFP_CALL_SERVICE_SIZE - 1] = 0;
1308a0ffb263SMatthias Ringwald             hfp_connection->remote_call_services_nr++;
13093deb3ec6SMatthias Ringwald             break;
1310aa4dd815SMatthias Ringwald         case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS:
1311aa4dd815SMatthias Ringwald         case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS:
1312a0ffb263SMatthias Ringwald             log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer);
13132308e108SMilanka Ringwald             hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer);
1314a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
1315a0ffb263SMatthias Ringwald             hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index;
13163deb3ec6SMatthias Ringwald             break;
1317aa4dd815SMatthias Ringwald         case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE:
13183deb3ec6SMatthias Ringwald             // HF parses inital AG gen. ind. state
1319a0ffb263SMatthias Ringwald             log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer);
13202308e108SMilanka Ringwald             hfp_connection->parser_item_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
13213deb3ec6SMatthias Ringwald             break;
1322ce263fc8SMatthias Ringwald         case HFP_CMD_HF_INDICATOR_STATUS:
13232308e108SMilanka Ringwald             hfp_connection->parser_indicator_index = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
1324a0ffb263SMatthias Ringwald             log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index);
1325ce263fc8SMatthias Ringwald             break;
13263deb3ec6SMatthias Ringwald         case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE:
13273deb3ec6SMatthias Ringwald             // AG parses new gen. ind. state
1328a0ffb263SMatthias Ringwald             if (hfp_connection->ignore_value){
1329a0ffb263SMatthias Ringwald                 hfp_connection->ignore_value = 0;
1330a0ffb263SMatthias Ringwald                 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index,
1331a0ffb263SMatthias Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled);
1332ce263fc8SMatthias Ringwald             }
1333a0ffb263SMatthias Ringwald             else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){
1334ce263fc8SMatthias Ringwald                 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n",
1335a0ffb263SMatthias Ringwald                     hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name);
1336ce263fc8SMatthias Ringwald             } else {
13372308e108SMilanka Ringwald                 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1338a0ffb263SMatthias Ringwald                 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value;
1339a0ffb263SMatthias Ringwald                 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index,
1340a0ffb263SMatthias Ringwald                     hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value);
13413deb3ec6SMatthias Ringwald             }
1342a0ffb263SMatthias Ringwald             hfp_connection->parser_item_index++;
13433deb3ec6SMatthias Ringwald             break;
13443deb3ec6SMatthias Ringwald         case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS:
13453deb3ec6SMatthias Ringwald             // indicators are indexed starting with 1
13462308e108SMilanka Ringwald             hfp_connection->parser_item_index = btstack_atoi((char *)&hfp_connection->line_buffer[0]) - 1;
1347a0ffb263SMatthias Ringwald             log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index);
13483deb3ec6SMatthias Ringwald             break;
1349aa4dd815SMatthias Ringwald         case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME:
13502308e108SMilanka Ringwald             hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]);
1351a0ffb263SMatthias Ringwald             log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode);
1352aa4dd815SMatthias Ringwald             break;
1353aa4dd815SMatthias Ringwald         case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT:
1354a0ffb263SMatthias Ringwald             if (hfp_connection->line_buffer[0] == '3'){
1355a0ffb263SMatthias Ringwald                 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer);
13563deb3ec6SMatthias Ringwald                 break;
13573deb3ec6SMatthias Ringwald             }
13583deb3ec6SMatthias Ringwald             // TODO emit ERROR, wrong format
1359a0ffb263SMatthias Ringwald             log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer);
13603deb3ec6SMatthias Ringwald             break;
13613deb3ec6SMatthias Ringwald         case HFP_CMD_ERROR:
13623deb3ec6SMatthias Ringwald             break;
13633deb3ec6SMatthias Ringwald         case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR:
1364a0ffb263SMatthias Ringwald             hfp_connection->extended_audio_gateway_error = 1;
13652308e108SMilanka Ringwald             hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
13663deb3ec6SMatthias Ringwald             break;
13673deb3ec6SMatthias Ringwald         case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR:
13682308e108SMilanka Ringwald             hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer);
1369a0ffb263SMatthias Ringwald             hfp_connection->ok_pending = 1;
1370a0ffb263SMatthias Ringwald             hfp_connection->extended_audio_gateway_error = 0;
13713deb3ec6SMatthias Ringwald             break;
1372ce263fc8SMatthias Ringwald         case HFP_CMD_AG_SENT_PHONE_NUMBER:
1373a0ffb263SMatthias Ringwald         case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE:
1374a0ffb263SMatthias Ringwald         case HFP_CMD_AG_SENT_CLIP_INFORMATION:
1375a0ffb263SMatthias Ringwald             strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number));
1376a0ffb263SMatthias Ringwald             hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0;
13773deb3ec6SMatthias Ringwald             break;
13783deb3ec6SMatthias Ringwald         default:
13793deb3ec6SMatthias Ringwald             break;
13803deb3ec6SMatthias Ringwald     }
13813deb3ec6SMatthias Ringwald }
13823deb3ec6SMatthias Ringwald 
1383323d3000SMatthias Ringwald void hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){
1384323d3000SMatthias Ringwald     hfp_connection_t * hfp_connection = provide_hfp_connection_context_for_bd_addr(bd_addr, local_role);
1385a0ffb263SMatthias Ringwald     log_info("hfp_connect %s, hfp_connection %p", bd_addr_to_str(bd_addr), hfp_connection);
13863deb3ec6SMatthias Ringwald 
1387a0ffb263SMatthias Ringwald     if (!hfp_connection) {
13883deb3ec6SMatthias Ringwald         log_error("hfp_establish_service_level_connection for addr %s failed", bd_addr_to_str(bd_addr));
13893deb3ec6SMatthias Ringwald         return;
13903deb3ec6SMatthias Ringwald     }
1391aa4dd815SMatthias Ringwald 
1392a0ffb263SMatthias Ringwald     switch (hfp_connection->state){
13933deb3ec6SMatthias Ringwald         case HFP_W2_DISCONNECT_RFCOMM:
1394a0ffb263SMatthias Ringwald             hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED;
13953deb3ec6SMatthias Ringwald             return;
13963deb3ec6SMatthias Ringwald         case HFP_W4_RFCOMM_DISCONNECTED:
1397a0ffb263SMatthias Ringwald             hfp_connection->state = HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART;
13983deb3ec6SMatthias Ringwald             return;
13993deb3ec6SMatthias Ringwald         case HFP_IDLE:
1400a0ffb263SMatthias Ringwald             memcpy(hfp_connection->remote_addr, bd_addr, 6);
1401d63c37a1SMatthias Ringwald             hfp_connection->state = HFP_W4_SDP_QUERY_COMPLETE;
1402a0ffb263SMatthias Ringwald             connection_doing_sdp_query = hfp_connection;
1403a0ffb263SMatthias Ringwald             hfp_connection->service_uuid = service_uuid;
14047fbb5f59SMatthias Ringwald             sdp_client_query_rfcomm_channel_and_name_for_uuid(&handle_query_rfcomm_event, hfp_connection->remote_addr, service_uuid);
14053deb3ec6SMatthias Ringwald             break;
14063deb3ec6SMatthias Ringwald         default:
14073deb3ec6SMatthias Ringwald             break;
14083deb3ec6SMatthias Ringwald     }
14093deb3ec6SMatthias Ringwald }
14103deb3ec6SMatthias Ringwald 
1411a0ffb263SMatthias Ringwald void hfp_release_service_level_connection(hfp_connection_t * hfp_connection){
1412a0ffb263SMatthias Ringwald     if (!hfp_connection) return;
1413a0ffb263SMatthias Ringwald     hfp_release_audio_connection(hfp_connection);
14143deb3ec6SMatthias Ringwald 
1415a0ffb263SMatthias Ringwald     if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){
1416a0ffb263SMatthias Ringwald         hfp_connection->state = HFP_IDLE;
14173deb3ec6SMatthias Ringwald         return;
14183deb3ec6SMatthias Ringwald     }
14193deb3ec6SMatthias Ringwald 
1420a0ffb263SMatthias Ringwald     if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){
1421a0ffb263SMatthias Ringwald         hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN;
14223deb3ec6SMatthias Ringwald         return;
14233deb3ec6SMatthias Ringwald     }
14243deb3ec6SMatthias Ringwald 
1425a0ffb263SMatthias Ringwald     if (hfp_connection->state < HFP_W4_SCO_CONNECTED){
1426a0ffb263SMatthias Ringwald         hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM;
14273deb3ec6SMatthias Ringwald         return;
14283deb3ec6SMatthias Ringwald     }
14293deb3ec6SMatthias Ringwald 
1430a0ffb263SMatthias Ringwald     if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){
1431a0ffb263SMatthias Ringwald         hfp_connection->state = HFP_W2_DISCONNECT_SCO;
14323deb3ec6SMatthias Ringwald         return;
14333deb3ec6SMatthias Ringwald     }
14343deb3ec6SMatthias Ringwald 
14353deb3ec6SMatthias Ringwald     return;
14363deb3ec6SMatthias Ringwald }
14373deb3ec6SMatthias Ringwald 
1438a0ffb263SMatthias Ringwald void hfp_release_audio_connection(hfp_connection_t * hfp_connection){
1439a0ffb263SMatthias Ringwald     if (!hfp_connection) return;
1440a0ffb263SMatthias Ringwald     if (hfp_connection->state >= HFP_W2_DISCONNECT_SCO) return;
1441a0ffb263SMatthias Ringwald     hfp_connection->release_audio_connection = 1;
14423deb3ec6SMatthias Ringwald }
14433deb3ec6SMatthias Ringwald 
1444ce263fc8SMatthias Ringwald static const struct link_settings {
1445ce263fc8SMatthias Ringwald     const uint16_t max_latency;
1446ce263fc8SMatthias Ringwald     const uint8_t  retransmission_effort;
1447ce263fc8SMatthias Ringwald     const uint16_t packet_types;
1448ce263fc8SMatthias Ringwald } hfp_link_settings [] = {
1449ce263fc8SMatthias Ringwald     { 0xffff, 0xff, 0x03c1 }, // HFP_LINK_SETTINGS_D0,   HV1
1450ce263fc8SMatthias Ringwald     { 0xffff, 0xff, 0x03c4 }, // HFP_LINK_SETTINGS_D1,   HV3
1451ce263fc8SMatthias Ringwald     { 0x0007, 0x01, 0x03c8 }, // HFP_LINK_SETTINGS_S1,   EV3
1452ce263fc8SMatthias Ringwald     { 0x0007, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S2, 2-EV3
1453ce263fc8SMatthias Ringwald     { 0x000a, 0x01, 0x0380 }, // HFP_LINK_SETTINGS_S3, 2-EV3
1454ce263fc8SMatthias Ringwald     { 0x000c, 0x02, 0x0380 }, // HFP_LINK_SETTINGS_S4, 2-EV3
1455ce263fc8SMatthias Ringwald     { 0x0008, 0x02, 0x03c8 }, // HFP_LINK_SETTINGS_T1,   EV3
1456ce263fc8SMatthias Ringwald     { 0x000d, 0x02, 0x0380 }  // HFP_LINK_SETTINGS_T2, 2-EV3
1457ce263fc8SMatthias Ringwald };
14583deb3ec6SMatthias Ringwald 
1459eddcd308SMatthias Ringwald void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){
1460ce263fc8SMatthias Ringwald     // all packet types, fixed bandwidth
1461eddcd308SMatthias Ringwald     int setting = hfp_connection->link_setting;
1462ce263fc8SMatthias Ringwald     log_info("hfp_setup_synchronous_connection using setting nr %u", setting);
1463eddcd308SMatthias Ringwald     sco_establishment_active = hfp_connection;
1464d2c1d59aSMatthias Ringwald     uint16_t sco_voice_setting = hci_get_sco_voice_setting();
1465d2c1d59aSMatthias Ringwald     if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){
14667522e673SMatthias Ringwald         sco_voice_setting = 0x0043; // Transparent data
1467d2c1d59aSMatthias Ringwald     }
1468eddcd308SMatthias Ringwald     hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency,
1469d2c1d59aSMatthias Ringwald         sco_voice_setting, hfp_link_settings[setting].retransmission_effort, hfp_link_settings[setting].packet_types); // all types 0x003f, only 2-ev3 0x380
1470ce263fc8SMatthias Ringwald }
1471d68dcce1SMatthias Ringwald 
1472*ca59be51SMatthias Ringwald void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){
1473*ca59be51SMatthias Ringwald     hfp_ag_rfcomm_packet_handler = handler;
1474*ca59be51SMatthias Ringwald }
1475*ca59be51SMatthias Ringwald void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){
1476*ca59be51SMatthias Ringwald     hfp_hf_rfcomm_packet_handler = handler;
1477d68dcce1SMatthias Ringwald }
1478d68dcce1SMatthias Ringwald 
1479