bt_status_t btif_shutdown_bluetooth(void) { BTIF_TRACE_DEBUG1("%s", __FUNCTION__); if (btif_is_enabled()) { BTIF_TRACE_WARNING0("shutdown while still enabled, initiate disable"); /* shutdown called prior to disabling, initiate disable */ btif_disable_bluetooth(); btif_shutdown_pending = 1; return BT_STATUS_NOT_READY; } btif_shutdown_pending = 0; GKI_destroy_task(BTIF_TASK); bte_main_shutdown(); btif_dut_mode = 0; BTIF_TRACE_DEBUG1("%s done", __FUNCTION__); return BT_STATUS_SUCCESS; }
int btpan_tap_send(int tap_fd, const BD_ADDR src, const BD_ADDR dst, UINT16 proto, const char* buf, UINT16 len, BOOLEAN ext, BOOLEAN forward) { if(tap_fd != -1) { tETH_HDR eth_hdr; //if(is_empty_eth_addr(dst)) // memcpy(ð_hdr.h_dest, local_addr, ETH_ADDR_LEN); //else memcpy(ð_hdr.h_dest, dst, ETH_ADDR_LEN); memcpy(ð_hdr.h_src, src, ETH_ADDR_LEN); eth_hdr.h_proto = htons(proto); char packet[2000]; memcpy(packet, ð_hdr, sizeof(tETH_HDR)); if(len > 2000) { ALOGE("btpan_tap_send eth packet size:%d is exceeded limit!", len); return -1; } memcpy(packet + sizeof(tETH_HDR), buf, len); /* Send data to network interface */ //btnet_send(btpan_cb.conn[i].sock.sock, &buffer, (len + sizeof(tETH_HDR))); //dump_bin("packet to network", packet, len + sizeof(tETH_HDR)); int ret = write(tap_fd, packet, len + sizeof(tETH_HDR)); BTIF_TRACE_DEBUG1("ret:%d", ret); return ret; } return -1; }
static bt_status_t btif_associate_evt(void) { BTIF_TRACE_DEBUG1("%s: notify ASSOCIATE_JVM", __FUNCTION__); HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM); return BT_STATUS_SUCCESS; }
static inline int should_forward(tETH_HDR* hdr) { if(ntohs(hdr->h_proto) == ETH_P_IP || ntohs(hdr->h_proto) == ETH_P_ARP) return TRUE; BTIF_TRACE_DEBUG1("unknown proto:%x", ntohs(hdr->h_proto)); return FALSE; }
void btpan_close_handle(btpan_conn_t *p) { BTIF_TRACE_DEBUG1("btpan_close_handle : close handle %d", p->handle); p->handle = -1; p->local_role = -1; p->remote_role = -1; memset(&p->peer, 0, 6); }
/******************************************************************************* ** ** Function btif_dut_mode_send ** ** Description Sends a HCI Vendor specific command to the controller ** ** Returns BT_STATUS_SUCCESS on success ** *******************************************************************************/ bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len) { /* TODO: Check that opcode is a vendor command group */ BTIF_TRACE_DEBUG1("%s", __FUNCTION__); BTM_VendorSpecificCommand(opcode, len, buf); return BT_STATUS_SUCCESS; }
static bt_status_t btpan_enable(int local_role) { int bta_pan_role; BTIF_TRACE_DEBUG1("local_role:%d", local_role); bta_pan_role = btpan_role_to_bta(local_role); BTA_PanSetRole(bta_pan_role, &bta_panu_info, NULL, &bta_pan_nap_info); btpan_dev_local_role = local_role; return BT_STATUS_SUCCESS; }
/*************************************************************************** ** ** Function btif_rc_handler ** ** Description RC event handler ** ***************************************************************************/ void btif_rc_handler(tBTA_AV_EVT event, tBTA_AV *p_data) { BTIF_TRACE_DEBUG2 ("%s event:%s", __FUNCTION__, dump_rc_event(event)); switch (event) { case BTA_AV_RC_OPEN_EVT: { BTIF_TRACE_DEBUG1("Peer_features:%x", p_data->rc_open.peer_features); handle_rc_connect( &(p_data->rc_open) ); }break; case BTA_AV_RC_CLOSE_EVT: { handle_rc_disconnect( &(p_data->rc_close) ); }break; case BTA_AV_REMOTE_CMD_EVT: { BTIF_TRACE_DEBUG2("rc_id:0x%x key_state:%d", p_data->remote_cmd.rc_id, p_data->remote_cmd.key_state); handle_rc_passthrough_cmd( (&p_data->remote_cmd) ); } break; case BTA_AV_RC_FEAT_EVT: { BTIF_TRACE_DEBUG1("Peer_features:%x", p_data->rc_feat.peer_features); btif_rc_cb.rc_features = p_data->rc_feat.peer_features; /* TODO Handle RC_FEAT_EVT*/ } break; case BTA_AV_META_MSG_EVT: { BTIF_TRACE_DEBUG2("BTA_AV_META_MSG_EVT code:%d label:%d", p_data->meta_msg.code, p_data->meta_msg.label); BTIF_TRACE_DEBUG3(" company_id:0x%x len:%d handle:%d", p_data->meta_msg.company_id, p_data->meta_msg.len, p_data->meta_msg.rc_handle); /* handle the metamsg command */ handle_rc_metamsg_cmd(&(p_data->meta_msg)); } break; default: BTIF_TRACE_DEBUG1("Unhandled RC event : 0x%x", event); } }
void close_uinput (void) { BTIF_TRACE_DEBUG1("%s", __FUNCTION__); if (uinput_fd > 0) { ioctl(uinput_fd, UI_DEV_DESTROY); close(uinput_fd); uinput_fd = -1; } }
int sock_send_fd(int sock_fd, const uint8_t* buf, int len, int send_fd) { ssize_t ret; struct msghdr msg; unsigned char *buffer = (unsigned char *)buf; memset(&msg, 0, sizeof(msg)); struct cmsghdr *cmsg; char msgbuf[CMSG_SPACE(1)]; asrt(send_fd != -1); if(sock_fd == -1 || send_fd == -1) return -1; // Add any pending outbound file descriptors to the message // See "man cmsg" really msg.msg_control = msgbuf; msg.msg_controllen = sizeof msgbuf; cmsg = CMSG_FIRSTHDR(&msg); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(sizeof send_fd); memcpy(CMSG_DATA(cmsg), &send_fd, sizeof send_fd); // We only write our msg_control during the first write int ret_len = len; while (len > 0) { struct iovec iv; memset(&iv, 0, sizeof(iv)); iv.iov_base = buffer; iv.iov_len = len; msg.msg_iov = &iv; msg.msg_iovlen = 1; do { ret = sendmsg(sock_fd, &msg, MSG_NOSIGNAL); } while (ret < 0 && errno == EINTR); if (ret < 0) { BTIF_TRACE_ERROR5("fd:%d, send_fd:%d, sendmsg ret:%d, errno:%d, %s", sock_fd, send_fd, (int)ret, errno, strerror(errno)); ret_len = -1; break; } buffer += ret; len -= ret; // Wipes out any msg_control too memset(&msg, 0, sizeof(msg)); } BTIF_TRACE_DEBUG1("close fd:%d after sent", send_fd); close(send_fd); return ret_len; }
static bt_status_t btif_disassociate_evt(void) { BTIF_TRACE_DEBUG1("%s: notify DISASSOCIATE_JVM", __FUNCTION__); HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM); /* shutdown complete, all events notified and we reset HAL callbacks */ bt_hal_cbacks = NULL; return BT_STATUS_SUCCESS; }
static int tap_if_up(const char *devname, BD_ADDR addr) { struct ifreq ifr; int sk, err; sk = socket(AF_INET, SOCK_DGRAM, 0); //set mac addr memset(&ifr, 0, sizeof(ifr)); strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1); err = ioctl(sk, SIOCGIFHWADDR, &ifr); if(err < 0) { BTIF_TRACE_ERROR2("Could not get network hardware for interface:%s, errno:%s", devname, strerror(errno)); close(sk); return -1; } /* debug("found mac address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */ /* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */ /* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */ strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1); memcpy(ifr.ifr_hwaddr.sa_data, addr, 6); /* debug("setting bt address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */ /* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */ /* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */ err = ioctl(sk, SIOCSIFHWADDR, (caddr_t)&ifr); if (err < 0) { BTIF_TRACE_ERROR2("Could not set bt address for interface:%s, errno:%s", devname, strerror(errno)); close(sk); return -1; } //bring it up memset(&ifr, 0, sizeof(ifr)); strncpy(ifr.ifr_name, devname, IF_NAMESIZE - 1); ifr.ifr_flags |= IFF_UP; ifr.ifr_flags |= IFF_MULTICAST; err = ioctl(sk, SIOCSIFFLAGS, (caddr_t) &ifr); if (err < 0) { BTIF_TRACE_ERROR2("Could not bring up network interface:%s, errno:%d", devname, errno); close(sk); return -1; } close(sk); BTIF_TRACE_DEBUG1("network interface: %s is up", devname); return 0; }
static inline int btpan_role_to_bta(int btpan_role) { int bta_pan_role = PAN_ROLE_INACTIVE; BTIF_TRACE_DEBUG1("btpan_role:0x%x", btpan_role); if(btpan_role & BTPAN_ROLE_PANNAP) { bta_pan_role |= PAN_ROLE_NAP_SERVER; } if(btpan_role & BTPAN_ROLE_PANU) { bta_pan_role |= PAN_ROLE_CLIENT; } return bta_pan_role; }
static inline int bta_role_to_btpan(int bta_pan_role) { int btpan_role = 0; BTIF_TRACE_DEBUG1("bta_pan_role:0x%x", bta_pan_role); if(bta_pan_role & PAN_ROLE_NAP_SERVER) { btpan_role |= BTPAN_ROLE_PANNAP; } if(bta_pan_role & PAN_ROLE_CLIENT) { btpan_role |= BTPAN_ROLE_PANU; } return btpan_role; }
int init_uinput (void) { char *name = "AVRCP"; BTIF_TRACE_DEBUG1("%s", __FUNCTION__); uinput_fd = uinput_create(name); if (uinput_fd < 0) { BTIF_TRACE_ERROR3("%s AVRCP: Failed to initialize uinput for %s (%d)", __FUNCTION__, name, uinput_fd); } else { BTIF_TRACE_DEBUG3("%s AVRCP: Initialized uinput for %s (fd=%d)", __FUNCTION__, name, uinput_fd); } return uinput_fd; }
static bt_status_t btif_mp_test_evt(void* msg) { BT_HDR *p_msg = (BT_HDR *)msg; UINT8 *p = (UINT8 *)(p_msg + 1) + p_msg->offset; UINT8 hci_evt_len; UINT8 hci_evt_code; STREAM_TO_UINT8 (hci_evt_code, p); STREAM_TO_UINT8 (hci_evt_len, p); BTIF_TRACE_DEBUG1("%s: notify btif_mp_test_evt", __FUNCTION__); if(btif_dut_mode) { btif_mp_rx_data_ind(hci_evt_code, (uint8_t*)p, hci_evt_len); } return BT_STATUS_SUCCESS; }
/******************************************************************************* ** ** Function btif_dut_mode_configure ** ** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits ** test mode ** ** Returns BT_STATUS_SUCCESS on success ** *******************************************************************************/ bt_status_t btif_dut_mode_configure(uint8_t enable) { BTIF_TRACE_DEBUG1("%s", __FUNCTION__); if (btif_core_state != BTIF_CORE_STATE_ENABLED) { BTIF_TRACE_ERROR0("btif_dut_mode_configure : Bluetooth not enabled"); return BT_STATUS_NOT_READY; } btif_dut_mode = enable; if (enable == 1) { btif_enable_test_mode(); } else { btif_disable_test_mode(); } return BT_STATUS_SUCCESS; }
static void forward_bnep(tETH_HDR* eth_hdr, char * packet, int size) { int broadcast = eth_hdr->h_dest[0] & 1; int i; for(i = 0; i < MAX_PAN_CONNS; i++) { UINT16 handle = btpan_cb.conns[i].handle; if(handle != (UINT16)-1 && (broadcast || memcmp(btpan_cb.conns[i].eth_addr, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0 || memcmp(btpan_cb.conns[i].peer, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0)) { BTIF_TRACE_DEBUG1("calling bta_pan_ci_rx_write, handle:%d", handle); bta_pan_ci_rx_write(handle, eth_hdr->h_dest, eth_hdr->h_src, ntohs(eth_hdr->h_proto), (UINT8*)packet, size, 0); break; } } }
btpan_conn_t* btpan_new_conn(int handle, const BD_ADDR addr, int local_role, int remote_role ) { int i; for(i = 0; i < MAX_PAN_CONNS; i++) { BTIF_TRACE_DEBUG2("conns[%d]:%d", i, btpan_cb.conns[i].handle); if(btpan_cb.conns[i].handle == -1) { BTIF_TRACE_DEBUG3("handle:%d, local_role:%d, remote_role:%d", handle, local_role, remote_role); btpan_cb.conns[i].handle = handle; bdcpy(btpan_cb.conns[i].peer, addr); btpan_cb.conns[i].local_role = local_role; btpan_cb.conns[i].remote_role = remote_role; return &btpan_cb.conns[i]; } } BTIF_TRACE_DEBUG1("MAX_PAN_CONNS:%d exceeded, return NULL as failed", MAX_PAN_CONNS); return NULL; }
/******************************************************************************* ** ** Function bta_hl_co_put_rx_data ** ** Description Put the received data ** ** Parameters app_id - HDP application ID ** mdl_handle - MDL handle ** data_size - the size of the data ** p_data - the data pointer ** evt - the evt to be passed back to the HL in the ** bta_hl_ci_put_rx_data call-in function ** ** Returns Void ** *******************************************************************************/ void bta_hl_co_put_rx_data (UINT8 app_id, tBTA_HL_MDL_HANDLE mdl_handle, UINT16 data_size, UINT8 *p_data, UINT16 evt) { UINT8 app_idx, mcl_idx, mdl_idx; btif_hl_mdl_cb_t *p_dcb; tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL; int r; BTIF_TRACE_DEBUG4("%s app_id=%d mdl_handle=0x%x data_size=%d", __FUNCTION__,app_id, mdl_handle, data_size); if (btif_hl_find_mdl_idx_using_handle(mdl_handle, &app_idx, &mcl_idx, &mdl_idx)) { p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); if ((p_dcb->p_rx_pkt = (UINT8 *)btif_hl_get_buf(data_size)) != NULL) { memcpy(p_dcb->p_rx_pkt, p_data, data_size); if (p_dcb->p_scb) { BTIF_TRACE_DEBUG4("app_idx=%d mcl_idx=0x%x mdl_idx=0x%x data_size=%d", app_idx, mcl_idx, mdl_idx, data_size); r = send(p_dcb->p_scb->socket_id[1], p_dcb->p_rx_pkt, data_size, 0); if (r == data_size) { BTIF_TRACE_DEBUG1("socket send success data_size=%d", data_size); status = BTA_HL_STATUS_OK; } else { BTIF_TRACE_ERROR2("socket send failed r=%d data_size=%d",r, data_size); } } btif_hl_free_buf((void **) &p_dcb->p_rx_pkt); } } bta_hl_ci_put_rx_data(mdl_handle, status, evt); }
static void btpan_close_conn(btpan_conn_t* conn) { BTIF_TRACE_DEBUG1("btpan_close_conn: %p",conn); if (conn && conn->state == PAN_STATE_OPEN) { BTIF_TRACE_DEBUG0("btpan_close_conn: PAN_STATE_OPEN"); conn->state = PAN_STATE_CLOSE; btpan_cb.open_count--; if (btpan_cb.open_count == 0) { destroy_tap_read_thread(); if (btpan_cb.tap_fd != -1) { btpan_tap_close(btpan_cb.tap_fd); btpan_cb.tap_fd = -1; } } } }
static bt_status_t phone_state_change(int num_active, int num_held, bthf_call_state_t call_setup_state, const char *number, bthf_call_addrtype_t type) { tBTA_AG_RES res = 0xff; tBTA_AG_RES_DATA ag_res; bt_status_t status = BT_STATUS_SUCCESS; BOOLEAN activeCallUpdated = FALSE; CHECK_BTHF_SLC_CONNECTED(); BTIF_TRACE_DEBUG6("phone_state_change: num_active=%d [prev: %d] num_held=%d[prev: %d]"\ " call_setup=%s [prev: %s]", num_active, btif_hf_cb.num_active, num_held, btif_hf_cb.num_held, dump_hf_call_state(call_setup_state), dump_hf_call_state(btif_hf_cb.call_setup_state)); /* if all indicators are 0, send end call and return */ if (num_active == 0 && num_held == 0 && call_setup_state == BTHF_CALL_STATE_IDLE) { BTIF_TRACE_DEBUG1("%s: Phone on hook", __FUNCTION__); /* record call termination timestamp if there was an active/held call or callsetup state > BTHF_CALL_STATE_IDLE */ if ((btif_hf_cb.call_setup_state != BTHF_CALL_STATE_IDLE ) || (btif_hf_cb.num_active) ||(btif_hf_cb.num_held)) { BTIF_TRACE_DEBUG1("%s: Record call termination timestamp", __FUNCTION__); clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb.call_end_timestamp); } BTA_AgResult (BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL); /* if held call was present, reset that as well */ if (btif_hf_cb.num_held) send_indicator_update(BTA_AG_IND_CALLHELD, 0); goto update_call_states; } /* active state can change when: ** 1. an outgoing/incoming call was answered ** 2. an held was resumed ** 3. without callsetup notifications, call became active ** (3) can happen if call is active and a headset connects to us ** ** In the case of (3), we will have to notify the stack of an active ** call, instead of sending an indicator update. This will also ** force the SCO to be setup. Handle this special case here prior to ** call setup handling */ if ( (num_active == 1) && (btif_hf_cb.num_active == 0) && (btif_hf_cb.num_held == 0) && (btif_hf_cb.call_setup_state == BTHF_CALL_STATE_IDLE) ) { BTIF_TRACE_DEBUG1("%s: Active call notification received without call setup update", __FUNCTION__); memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); ag_res.audio_handle = btif_hf_cb.handle; res = BTA_AG_OUT_CALL_CONN_RES; BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res); activeCallUpdated = TRUE; } /* Ringing call changed? */ if (call_setup_state != btif_hf_cb.call_setup_state) { BTIF_TRACE_DEBUG3("%s: Call setup states changed. old: %s new: %s", __FUNCTION__, dump_hf_call_state(btif_hf_cb.call_setup_state), dump_hf_call_state(call_setup_state)); memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); switch (call_setup_state) { case BTHF_CALL_STATE_IDLE: { switch (btif_hf_cb.call_setup_state) { case BTHF_CALL_STATE_INCOMING: if (num_active > btif_hf_cb.num_active) { res = BTA_AG_IN_CALL_CONN_RES; ag_res.audio_handle = btif_hf_cb.handle; } else if (num_held > btif_hf_cb.num_held) res = BTA_AG_IN_CALL_HELD_RES; else res = BTA_AG_CALL_CANCEL_RES; break; case BTHF_CALL_STATE_DIALING: case BTHF_CALL_STATE_ALERTING: if (num_active > btif_hf_cb.num_active) { ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE; res = BTA_AG_OUT_CALL_CONN_RES; } else res = BTA_AG_CALL_CANCEL_RES; break; default: BTIF_TRACE_ERROR1("%s: Incorrect Call setup state transition", __FUNCTION__); status = BT_STATUS_PARM_INVALID; break; } } break; case BTHF_CALL_STATE_INCOMING: if (num_active || num_held) res = BTA_AG_CALL_WAIT_RES; else res = BTA_AG_IN_CALL_RES; if (number) { int xx = 0; if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+')) xx = sprintf (ag_res.str, "\"+%s\"", number); else xx = sprintf (ag_res.str, "\"%s\"", number); ag_res.num = type; if (res == BTA_AG_CALL_WAIT_RES) sprintf(&ag_res.str[xx], ",%d", type); } break; case BTHF_CALL_STATE_DIALING: ag_res.audio_handle = btif_hf_cb.handle; res = BTA_AG_OUT_CALL_ORIG_RES; break; case BTHF_CALL_STATE_ALERTING: /* if we went from idle->alert, force SCO setup here. dialing usually triggers it */ if (btif_hf_cb.call_setup_state == BTHF_CALL_STATE_IDLE) ag_res.audio_handle = btif_hf_cb.handle; res = BTA_AG_OUT_CALL_ALERT_RES; break; default: BTIF_TRACE_ERROR1("%s: Incorrect new ringing call state", __FUNCTION__); status = BT_STATUS_PARM_INVALID; break; } BTIF_TRACE_DEBUG3("%s: Call setup state changed. res=%d, audio_handle=%d", __FUNCTION__, res, ag_res.audio_handle); if (res) BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res); /* if call setup is idle, we have already updated call indicator, jump out */ if (call_setup_state == BTHF_CALL_STATE_IDLE) { /* check & update callheld */ if ((num_held > 0) && (num_active > 0)) send_indicator_update(BTA_AG_IND_CALLHELD, 1); goto update_call_states; } } memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); /* per the errata 2043, call=1 implies atleast one call is in progress (active/held) ** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043 ** Handle call indicator change **/ if (!activeCallUpdated && ((num_active + num_held) != (btif_hf_cb.num_active + btif_hf_cb.num_held)) ) { BTIF_TRACE_DEBUG3("%s: Active call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb.num_active, num_active); send_indicator_update(BTA_AG_IND_CALL, ((num_active + num_held) > 0) ? 1 : 0); } /* Held Changed? */ if (num_held != btif_hf_cb.num_held) { BTIF_TRACE_DEBUG3("%s: Held call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb.num_held, num_held); send_indicator_update(BTA_AG_IND_CALLHELD, ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); } /* Calls Swapped? */ if ( (call_setup_state == btif_hf_cb.call_setup_state) && (num_active && num_held) && (num_active == btif_hf_cb.num_active) && (num_held == btif_hf_cb.num_held) ) { BTIF_TRACE_DEBUG1("%s: Calls swapped", __FUNCTION__); send_indicator_update(BTA_AG_IND_CALLHELD, 1); } update_call_states: btif_hf_cb.num_active = num_active; btif_hf_cb.num_held = num_held; btif_hf_cb.call_setup_state = call_setup_state; return status; }
static int btpan_get_local_role() { BTIF_TRACE_DEBUG1("btpan_dev_local_role:%d", btpan_dev_local_role); return btpan_dev_local_role; }