/****************************************************************************** * * Copyright (C) 2009-2012 Broadcom Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /****************************************************************************** * * Filename: hci_h4.c * * Description: Contains HCI transport send/receive functions * ******************************************************************************/ #define LOG_TAG "bt_h4" #include #include #include #include "bt_hci_bdroid.h" #include "hci.h" #include "userial.h" #include "utils.h" /****************************************************************************** ** Constants & Macros ******************************************************************************/ #ifndef HCI_DBG #define HCI_DBG FALSE #endif #if (HCI_DBG == TRUE) #define HCIDBG(param, ...) {LOGD(param, ## __VA_ARGS__);} #else #define HCIDBG(param, ...) {} #endif /* Preamble length for HCI Commands: ** 2-bytes for opcode and 1 byte for length */ #define HCI_CMD_PREAMBLE_SIZE 3 /* Preamble length for HCI Events: ** 1-byte for opcode and 1 byte for length */ #define HCI_EVT_PREAMBLE_SIZE 2 /* Preamble length for SCO Data: ** 2-byte for Handle and 1 byte for length */ #define HCI_SCO_PREAMBLE_SIZE 3 /* Preamble length for ACL Data: ** 2-byte for Handle and 2 byte for length */ #define HCI_ACL_PREAMBLE_SIZE 4 /* Table of HCI preamble sizes for the different HCI message types */ static const uint8_t hci_preamble_table[] = { HCI_CMD_PREAMBLE_SIZE, HCI_ACL_PREAMBLE_SIZE, HCI_SCO_PREAMBLE_SIZE, HCI_EVT_PREAMBLE_SIZE }; /* HCI H4 message type definitions */ #define H4_TYPE_COMMAND 1 #define H4_TYPE_ACL_DATA 2 #define H4_TYPE_SCO_DATA 3 #define H4_TYPE_EVENT 4 static const uint16_t msg_evt_table[] = { MSG_HC_TO_STACK_HCI_ERR, /* H4_TYPE_COMMAND */ MSG_HC_TO_STACK_HCI_ACL, /* H4_TYPE_ACL_DATA */ MSG_HC_TO_STACK_HCI_SCO, /* H4_TYPE_SCO_DATA */ MSG_HC_TO_STACK_HCI_EVT /* H4_TYPE_EVENT */ }; #define ACL_RX_PKT_START 2 #define ACL_RX_PKT_CONTINUE 1 #define L2CAP_HEADER_SIZE 4 /* Maximum numbers of allowed internal ** outstanding command packets at any time */ #define INT_CMD_PKT_MAX_COUNT 8 #define INT_CMD_PKT_IDX_MASK 0x07 #define HCI_COMMAND_COMPLETE_EVT 0x0E #define HCI_COMMAND_STATUS_EVT 0x0F #define HCI_VENDOR_EVT 0xFF #define HCI_READ_BUFFER_SIZE 0x1005 #define HCI_LE_READ_BUFFER_SIZE 0x2002 /****************************************************************************** ** Local type definitions ******************************************************************************/ /* H4 Rx States */ typedef enum { H4_RX_MSGTYPE_ST, H4_RX_LEN_ST, H4_RX_DATA_ST, H4_RX_IGNORE_ST } tHCI_H4_RCV_STATE; /* Callback function for the returned event of internal issued command */ typedef void (*tINT_CMD_CBACK)(void *p_mem); typedef struct { uint16_t opcode; /* OPCODE of outstanding internal commands */ tINT_CMD_CBACK cback; /* Callback function when return of internal * command is received */ } tINT_CMD_Q; /* Control block for HCISU_H4 */ typedef struct { HC_BT_HDR *p_rcv_msg; /* Buffer to hold current rx HCI message */ uint16_t rcv_len; /* Size of current incoming message */ uint8_t rcv_msg_type; /* Current incoming message type */ tHCI_H4_RCV_STATE rcv_state; /* Receive state of current rx message */ uint16_t hc_acl_data_size; /* Controller's max ACL data length */ uint16_t hc_ble_acl_data_size; /* Controller's max BLE ACL data length */ BUFFER_Q acl_rx_q; /* Queue of base buffers for fragmented ACL pkts */ uint8_t preload_count; /* Count numbers of preload bytes */ uint8_t preload_buffer[6]; /* HCI_ACL_PREAMBLE_SIZE + 2 */ int int_cmd_rsp_pending; /* Num of internal cmds pending for ack */ uint8_t int_cmd_rd_idx; /* Read index of int_cmd_opcode queue */ uint8_t int_cmd_wrt_idx; /* Write index of int_cmd_opcode queue */ tINT_CMD_Q int_cmd[INT_CMD_PKT_MAX_COUNT]; /* FIFO queue */ } tHCI_H4_CB; /****************************************************************************** ** Externs ******************************************************************************/ extern BUFFER_Q tx_q; void btsnoop_init(void); void btsnoop_close(void); void btsnoop_cleanup (void); void btsnoop_capture(HC_BT_HDR *p_buf, uint8_t is_rcvd); uint8_t hci_h4_send_int_cmd(uint16_t opcode, HC_BT_HDR *p_buf, \ tINT_CMD_CBACK p_cback); void lpm_wake_assert(void); void lpm_tx_done(uint8_t is_tx_done); /****************************************************************************** ** Variables ******************************************************************************/ /* Num of allowed outstanding HCI CMD packets */ volatile int num_hci_cmd_pkts = 1; /****************************************************************************** ** Static variables ******************************************************************************/ static tHCI_H4_CB h4_cb; /****************************************************************************** ** Static functions ******************************************************************************/ /******************************************************************************* ** ** Function get_acl_data_length_cback ** ** Description Callback function for HCI_READ_BUFFER_SIZE and ** HCI_LE_READ_BUFFER_SIZE commands if they were sent because ** of internal request. ** ** Returns None ** *******************************************************************************/ void get_acl_data_length_cback(void *p_mem) { uint8_t *p, status; uint16_t opcode, len=0; HC_BT_HDR *p_buf = (HC_BT_HDR *) p_mem; p = (uint8_t *)(p_buf + 1) + 3; STREAM_TO_UINT16(opcode, p) status = *p++; if (status == 0) /* Success */ STREAM_TO_UINT16(len, p) if (opcode == HCI_READ_BUFFER_SIZE) { if (status == 0) h4_cb.hc_acl_data_size = len; /* reuse the rx buffer for sending HCI_LE_READ_BUFFER_SIZE command */ p_buf->event = MSG_STACK_TO_HC_HCI_CMD; p_buf->offset = 0; p_buf->layer_specific = 0; p_buf->len = 3; p = (uint8_t *) (p_buf + 1); UINT16_TO_STREAM(p, HCI_LE_READ_BUFFER_SIZE); *p = 0; if ((status = hci_h4_send_int_cmd(HCI_LE_READ_BUFFER_SIZE, p_buf, \ get_acl_data_length_cback)) == FALSE) { bt_hc_cbacks->dealloc((TRANSAC) p_buf, (char *) (p_buf + 1)); bt_hc_cbacks->postload_cb(NULL, BT_HC_POSTLOAD_SUCCESS); } } else if (opcode == HCI_LE_READ_BUFFER_SIZE) { if (status == 0) h4_cb.hc_ble_acl_data_size = (len) ? len : h4_cb.hc_acl_data_size; if (bt_hc_cbacks) { bt_hc_cbacks->dealloc((TRANSAC) p_buf, (char *) (p_buf + 1)); ALOGE("vendor lib postload completed"); bt_hc_cbacks->postload_cb(NULL, BT_HC_POSTLOAD_SUCCESS); } } } /******************************************************************************* ** ** Function internal_event_intercept ** ** Description This function is called to parse received HCI event and ** - update the Num_HCI_Command_Packets ** - intercept the event if it is the result of an early ** issued internal command. ** ** Returns TRUE : if the event had been intercepted for internal process ** FALSE : send this event to core stack ** *******************************************************************************/ uint8_t internal_event_intercept(void) { uint8_t *p; uint8_t event_code; uint16_t opcode, len; tHCI_H4_CB *p_cb = &h4_cb; p = (uint8_t *)(p_cb->p_rcv_msg + 1); event_code = *p++; len = *p++; if (event_code == HCI_COMMAND_COMPLETE_EVT) { num_hci_cmd_pkts = *p++; if (p_cb->int_cmd_rsp_pending > 0) { STREAM_TO_UINT16(opcode, p) if (opcode == p_cb->int_cmd[p_cb->int_cmd_rd_idx].opcode) { HCIDBG( \ "Intercept CommandCompleteEvent for internal command (0x%04X)",\ opcode); if (p_cb->int_cmd[p_cb->int_cmd_rd_idx].cback != NULL) { p_cb->int_cmd[p_cb->int_cmd_rd_idx].cback(p_cb->p_rcv_msg); } else { // Missing cback function! // Release the p_rcv_msg buffer. if (bt_hc_cbacks) { bt_hc_cbacks->dealloc((TRANSAC) p_cb->p_rcv_msg, \ (char *) (p_cb->p_rcv_msg + 1)); } } p_cb->int_cmd_rd_idx = ((p_cb->int_cmd_rd_idx+1) & \ INT_CMD_PKT_IDX_MASK); p_cb->int_cmd_rsp_pending--; return TRUE; } } } else if (event_code == HCI_VENDOR_EVT) { num_hci_cmd_pkts = *p++; if (p_cb->int_cmd_rsp_pending > 0) { HCIDBG( \ "Intercept CommandCompleteEvent for internal command (0x%04X)",\ p_cb->int_cmd[p_cb->int_cmd_rd_idx].opcode); if (p_cb->int_cmd[p_cb->int_cmd_rd_idx].cback != NULL) { p_cb->int_cmd[p_cb->int_cmd_rd_idx].cback(p_cb->p_rcv_msg); } else { // Missing cback function! // Release the p_rcv_msg buffer. if (bt_hc_cbacks) { bt_hc_cbacks->dealloc((TRANSAC) p_cb->p_rcv_msg, \ (char *) (p_cb->p_rcv_msg + 1)); } } p_cb->int_cmd_rd_idx = ((p_cb->int_cmd_rd_idx+1) & \ INT_CMD_PKT_IDX_MASK); p_cb->int_cmd_rsp_pending--; return TRUE; } } else if (event_code == HCI_COMMAND_STATUS_EVT) { num_hci_cmd_pkts = *(++p); } return FALSE; } /******************************************************************************* ** ** Function acl_rx_frame_buffer_alloc ** ** Description This function is called from the HCI transport when the ** first 4 or 6 bytes of an HCI ACL packet have been received: ** - Allocate a new buffer if it is a start pakcet of L2CAP ** message. ** - Return the buffer address of the starting L2CAP message ** frame if the packet is the next segment of a fragmented ** L2CAP message. ** ** Returns the address of the receive buffer H4 RX should use ** (CR419: Modified to return NULL in case of error.) ** ** NOTE This assumes that the L2CAP MTU size is less than the size ** of an HCI ACL buffer, so the maximum L2CAP message will fit ** into one buffer. ** *******************************************************************************/ static HC_BT_HDR *acl_rx_frame_buffer_alloc (void) { uint8_t *p; uint16_t handle; uint16_t hci_len; uint16_t total_len; uint8_t pkt_type; HC_BT_HDR *p_return_buf = NULL; tHCI_H4_CB *p_cb = &h4_cb; p = p_cb->preload_buffer; STREAM_TO_UINT16 (handle, p); STREAM_TO_UINT16 (hci_len, p); STREAM_TO_UINT16 (total_len, p); pkt_type = (uint8_t)(((handle) >> 12) & 0x0003); handle = (uint16_t)((handle) & 0x0FFF); if (p_cb->acl_rx_q.count) { uint16_t save_handle; HC_BT_HDR *p_hdr = p_cb->acl_rx_q.p_first; while (p_hdr != NULL) { p = (uint8_t *)(p_hdr + 1); STREAM_TO_UINT16 (save_handle, p); save_handle = (uint16_t)((save_handle) & 0x0FFF); if (save_handle == handle) { p_return_buf = p_hdr; break; } p_hdr = utils_getnext(p_hdr); } } if (pkt_type == ACL_RX_PKT_START) /*** START PACKET ***/ { /* Might have read 2 bytes for the L2CAP payload length */ p_cb->rcv_len = (hci_len) ? (hci_len - 2) : 0; /* Start of packet. If we were in the middle of receiving */ /* a packet on the same ACL handle, the original packet is incomplete. * Drop it. */ if (p_return_buf) { ALOGW("H4 - dropping incomplete ACL frame"); utils_remove_from_queue(&(p_cb->acl_rx_q), p_return_buf); if (bt_hc_cbacks) { bt_hc_cbacks->dealloc((TRANSAC) p_return_buf, \ (char *) (p_return_buf + 1)); } p_return_buf = NULL; } /* Allocate a buffer for message */ if (bt_hc_cbacks) { int len = total_len + HCI_ACL_PREAMBLE_SIZE + L2CAP_HEADER_SIZE + \ BT_HC_HDR_SIZE; p_return_buf = (HC_BT_HDR *) bt_hc_cbacks->alloc(len); } if (p_return_buf) { /* Initialize buffer with preloaded data */ p_return_buf->offset = 0; p_return_buf->layer_specific = 0; p_return_buf->event = MSG_HC_TO_STACK_HCI_ACL; p_return_buf->len = p_cb->preload_count; memcpy((uint8_t *)(p_return_buf + 1), p_cb->preload_buffer, \ p_cb->preload_count); if (hci_len && ((total_len + L2CAP_HEADER_SIZE) > hci_len)) { /* Will expect to see fragmented ACL packets */ /* Keep the base buffer address in the watching queue */ utils_enqueue(&(p_cb->acl_rx_q), p_return_buf); } } } else /*** CONTINUATION PACKET ***/ { p_cb->rcv_len = hci_len; if (p_return_buf) { /* Packet continuation and found the original rx buffer */ uint8_t *p_f = p = (uint8_t *)(p_return_buf + 1) + 2; STREAM_TO_UINT16 (total_len, p); /* Update HCI header of first segment (base buffer) with new len */ total_len += hci_len; UINT16_TO_STREAM (p_f, total_len); } } return (p_return_buf); } /******************************************************************************* ** ** Function acl_rx_frame_end_chk ** ** Description This function is called from the HCI transport when the last ** byte of an HCI ACL packet has been received. It checks if ** the L2CAP message is complete, i.e. no more continuation ** packets are expected. ** ** Returns TRUE if message complete, FALSE if continuation expected ** *******************************************************************************/ static uint8_t acl_rx_frame_end_chk (void) { uint8_t *p; uint16_t handle, hci_len, l2cap_len; HC_BT_HDR *p_buf; tHCI_H4_CB *p_cb = &h4_cb; uint8_t frame_end=TRUE; p_buf = p_cb->p_rcv_msg; p = (uint8_t *)(p_buf + 1); STREAM_TO_UINT16 (handle, p); STREAM_TO_UINT16 (hci_len, p); STREAM_TO_UINT16 (l2cap_len, p); if (hci_len > 0) { if (l2cap_len > (p_buf->len-(HCI_ACL_PREAMBLE_SIZE+L2CAP_HEADER_SIZE)) ) { /* If the L2CAP length has not been reached, tell H4 not to send * this buffer to stack */ frame_end = FALSE; } else { /* * The current buffer coulb be in the watching list. * Remove it from the list if it is in. */ if (p_cb->acl_rx_q.count) utils_remove_from_queue(&(p_cb->acl_rx_q), p_buf); } } /**** ** Print snoop trace ****/ if (p_buf->offset) { /* CONTINUATION PACKET */ /* save original p_buf->len content */ uint16_t tmp_u16 = p_buf->len; /* borrow HCI_ACL_PREAMBLE_SIZE bytes from the payload section */ p = (uint8_t *)(p_buf + 1) + p_buf->offset - HCI_ACL_PREAMBLE_SIZE; /* save contents */ memcpy(p_cb->preload_buffer, p, HCI_ACL_PREAMBLE_SIZE); /* Set packet boundary flags to "continuation packet" */ handle = (handle & 0xCFFF) | 0x1000; /* write handl & length info */ UINT16_TO_STREAM (p, handle); UINT16_TO_STREAM (p, (p_buf->len - p_buf->offset)); /* roll pointer back */ p = p - HCI_ACL_PREAMBLE_SIZE; /* adjust `p_buf->offset` & `p_buf->len` * before calling btsnoop_capture() */ p_buf->offset = p_buf->offset - HCI_ACL_PREAMBLE_SIZE; p_buf->len = p_buf->len - p_buf->offset; btsnoop_capture(p_buf, TRUE); /* restore contents */ memcpy(p, p_cb->preload_buffer, HCI_ACL_PREAMBLE_SIZE); /* restore p_buf->len */ p_buf->len = tmp_u16; } else { /* START PACKET */ btsnoop_capture(p_buf, TRUE); } if (frame_end == TRUE) p_buf->offset = 0; else p_buf->offset = p_buf->len; /* save current buffer-end position */ return frame_end; } /***************************************************************************** ** HCI H4 INTERFACE FUNCTIONS *****************************************************************************/ /******************************************************************************* ** ** Function hci_h4_init ** ** Description Initialize H4 module ** ** Returns None ** *******************************************************************************/ void hci_h4_init(void) { HCIDBG("hci_h4_init"); memset(&h4_cb, 0, sizeof(tHCI_H4_CB)); utils_queue_init(&(h4_cb.acl_rx_q)); /* Per HCI spec., always starts with 1 */ num_hci_cmd_pkts = 1; /* Give an initial values of Host Controller's ACL data packet length * Will update with an internal HCI(_LE)_Read_Buffer_Size request */ h4_cb.hc_acl_data_size = 1021; h4_cb.hc_ble_acl_data_size = 27; btsnoop_init(); } /******************************************************************************* ** ** Function hci_h4_cleanup ** ** Description Clean H4 module ** ** Returns None ** *******************************************************************************/ void hci_h4_cleanup(void) { HCIDBG("hci_h4_cleanup"); btsnoop_close(); btsnoop_cleanup(); } /******************************************************************************* ** ** Function hci_h4_send_msg ** ** Description Determine message type, set HCI H4 packet indicator, and ** send message through USERIAL driver ** ** Returns None ** *******************************************************************************/ void hci_h4_send_msg(HC_BT_HDR *p_msg) { uint8_t type = 0; uint16_t handle; uint16_t bytes_to_send, lay_spec; uint8_t *p = ((uint8_t *)(p_msg + 1)) + p_msg->offset; uint16_t event = p_msg->event & MSG_EVT_MASK; uint16_t sub_event = p_msg->event & MSG_SUB_EVT_MASK; uint16_t acl_pkt_size = 0, acl_data_size = 0; uint16_t bytes_sent; /* wake up BT device if its in sleep mode */ lpm_wake_assert(); if (event == MSG_STACK_TO_HC_HCI_ACL) type = H4_TYPE_ACL_DATA; else if (event == MSG_STACK_TO_HC_HCI_SCO) type = H4_TYPE_SCO_DATA; else if (event == MSG_STACK_TO_HC_HCI_CMD) type = H4_TYPE_COMMAND; if (sub_event == LOCAL_BR_EDR_CONTROLLER_ID) { acl_data_size = h4_cb.hc_acl_data_size; acl_pkt_size = h4_cb.hc_acl_data_size + HCI_ACL_PREAMBLE_SIZE; } else { acl_data_size = h4_cb.hc_ble_acl_data_size; acl_pkt_size = h4_cb.hc_ble_acl_data_size + HCI_ACL_PREAMBLE_SIZE; } /* Check if sending ACL data that needs fragmenting */ if ((event == MSG_STACK_TO_HC_HCI_ACL) && (p_msg->len > acl_pkt_size)) { /* Get the handle from the packet */ STREAM_TO_UINT16 (handle, p); /* Set packet boundary flags to "continuation packet" */ handle = (handle & 0xCFFF) | 0x1000; /* Do all the first chunks */ while (p_msg->len > acl_pkt_size) { /* remember layer_specific because uart borrow one byte from layer_specific for packet type */ lay_spec = p_msg->layer_specific; p = ((uint8_t *)(p_msg + 1)) + p_msg->offset - 1; *p = type; bytes_to_send = acl_pkt_size + 1; /* packet_size + message type */ bytes_sent = userial_write(event,(uint8_t *) p,bytes_to_send); /* generate snoop trace message */ btsnoop_capture(p_msg, FALSE); p_msg->layer_specific = lay_spec; /* Adjust offset and length for what we just sent */ p_msg->offset += acl_data_size; p_msg->len -= acl_data_size; p = ((uint8_t *)(p_msg + 1)) + p_msg->offset; UINT16_TO_STREAM (p, handle); if (p_msg->len > acl_pkt_size) { UINT16_TO_STREAM (p, acl_data_size); } else { UINT16_TO_STREAM (p, p_msg->len - HCI_ACL_PREAMBLE_SIZE); } /* If we were only to send partial buffer, stop when done. */ /* Send the buffer back to L2CAP to send the rest of it later */ if (p_msg->layer_specific) { if (--p_msg->layer_specific == 0) { p_msg->event = MSG_HC_TO_STACK_L2C_SEG_XMIT; if (bt_hc_cbacks) { bt_hc_cbacks->tx_result((TRANSAC) p_msg, \ (char *) (p_msg + 1), \ BT_HC_TX_FRAGMENT); } return; } } } } /* remember layer_specific because uart borrow one byte from layer_specific for packet type */ lay_spec = p_msg->layer_specific; /* Put the HCI Transport packet type 1 byte before the message */ p = ((uint8_t *)(p_msg + 1)) + p_msg->offset - 1; *p = type; bytes_to_send = p_msg->len + 1; /* message_size + message type */ bytes_sent = userial_write(event,(uint8_t *) p, bytes_to_send); p_msg->layer_specific = lay_spec; if (event == MSG_STACK_TO_HC_HCI_CMD) { num_hci_cmd_pkts--; /* If this is an internal Cmd packet, the layer_specific field would * have stored with the opcode of HCI command. * Retrieve the opcode from the Cmd packet. */ p++; STREAM_TO_UINT16(lay_spec, p); } /* generate snoop trace message */ btsnoop_capture(p_msg, FALSE); if (bt_hc_cbacks) { if ((event == MSG_STACK_TO_HC_HCI_CMD) && \ (h4_cb.int_cmd_rsp_pending > 0) && \ (p_msg->layer_specific == lay_spec)) { /* dealloc buffer of internal command */ bt_hc_cbacks->dealloc((TRANSAC) p_msg, (char *) (p_msg + 1)); } else { bt_hc_cbacks->tx_result((TRANSAC) p_msg, (char *) (p_msg + 1), \ BT_HC_TX_SUCCESS); } } lpm_tx_done(TRUE); return; } /******************************************************************************* ** ** Function hci_h4_receive_msg ** ** Description Construct HCI EVENT/ACL packets and send them to stack once ** complete packet has been received. ** ** Returns Number of read bytes ** *******************************************************************************/ uint16_t hci_h4_receive_msg(void) { uint16_t bytes_read = 0; uint8_t byte; uint16_t msg_len, len; uint8_t msg_received; tHCI_H4_CB *p_cb=&h4_cb; while (TRUE) { /* Read one byte to see if there is anything waiting to be read */ if (userial_read(0 /*dummy*/, &byte, 1) == 0) { break; } bytes_read++; msg_received = FALSE; switch (p_cb->rcv_state) { case H4_RX_MSGTYPE_ST: /* Start of new message */ if ((byte < H4_TYPE_ACL_DATA) || (byte > H4_TYPE_EVENT)) { /* Unknown HCI message type */ /* Drop this byte */ ALOGE("[h4] Unknown HCI message type drop this byte 0x%x", byte); break; } /* Initialize rx parameters */ p_cb->rcv_msg_type = byte; p_cb->rcv_len = hci_preamble_table[byte-1]; memset(p_cb->preload_buffer, 0 , 6); p_cb->preload_count = 0; // p_cb->p_rcv_msg = NULL; p_cb->rcv_state = H4_RX_LEN_ST; /* Next, wait for length to come */ break; case H4_RX_LEN_ST: /* Receiving preamble */ p_cb->preload_buffer[p_cb->preload_count++] = byte; p_cb->rcv_len--; /* Check if we received entire preamble yet */ if (p_cb->rcv_len == 0) { if (p_cb->rcv_msg_type == H4_TYPE_ACL_DATA) { /* ACL data lengths are 16-bits */ msg_len = p_cb->preload_buffer[3]; msg_len = (msg_len << 8) + p_cb->preload_buffer[2]; if (msg_len && (p_cb->preload_count == 4)) { /* Check if this is a start packet */ byte = ((p_cb->preload_buffer[1] >> 4) & 0x03); if (byte == ACL_RX_PKT_START) { /* * A start packet & with non-zero data payload length. * We want to read 2 more bytes to get L2CAP payload * length. */ p_cb->rcv_len = 2; break; } } /* * Check for segmented packets. If this is a continuation * packet, then we will continue appending data to the * original rcv buffer. */ p_cb->p_rcv_msg = acl_rx_frame_buffer_alloc(); } else { /* Received entire preamble. * Length is in the last received byte */ msg_len = byte; p_cb->rcv_len = msg_len; /* Allocate a buffer for message */ if (bt_hc_cbacks) { len = msg_len + p_cb->preload_count + BT_HC_HDR_SIZE; p_cb->p_rcv_msg = \ (HC_BT_HDR *) bt_hc_cbacks->alloc(len); } if (p_cb->p_rcv_msg) { /* Initialize buffer with preloaded data */ p_cb->p_rcv_msg->offset = 0; p_cb->p_rcv_msg->layer_specific = 0; p_cb->p_rcv_msg->event = \ msg_evt_table[p_cb->rcv_msg_type-1]; p_cb->p_rcv_msg->len = p_cb->preload_count; memcpy((uint8_t *)(p_cb->p_rcv_msg + 1), \ p_cb->preload_buffer, p_cb->preload_count); } } if (p_cb->p_rcv_msg == NULL) { /* Unable to acquire message buffer. */ ALOGE( \ "H4: Unable to acquire buffer for incoming HCI message." \ ); if (msg_len == 0) { /* Wait for next message */ p_cb->rcv_state = H4_RX_MSGTYPE_ST; } else { /* Ignore rest of the packet */ p_cb->rcv_state = H4_RX_IGNORE_ST; } break; } /* Message length is valid */ if (msg_len) { /* Read rest of message */ p_cb->rcv_state = H4_RX_DATA_ST; } else { /* Message has no additional parameters. * (Entire message has been received) */ if (p_cb->rcv_msg_type == H4_TYPE_ACL_DATA) acl_rx_frame_end_chk(); /* to print snoop trace */ msg_received = TRUE; /* Next, wait for next message */ p_cb->rcv_state = H4_RX_MSGTYPE_ST; } } break; case H4_RX_DATA_ST: *((uint8_t *)(p_cb->p_rcv_msg + 1) + p_cb->p_rcv_msg->len++) = byte; p_cb->rcv_len--; if (p_cb->rcv_len > 0) { /* Read in the rest of the message */ len = userial_read(0 /*dummy*/, \ ((uint8_t *)(p_cb->p_rcv_msg+1) + p_cb->p_rcv_msg->len), \ p_cb->rcv_len); p_cb->p_rcv_msg->len += len; p_cb->rcv_len -= len; bytes_read += len; } /* Check if we read in entire message yet */ if (p_cb->rcv_len == 0) { /* Received entire packet. */ /* Check for segmented l2cap packets */ if ((p_cb->rcv_msg_type == H4_TYPE_ACL_DATA) && !acl_rx_frame_end_chk()) { /* Not the end of packet yet. */ /* Next, wait for next message */ p_cb->rcv_state = H4_RX_MSGTYPE_ST; } else { msg_received = TRUE; /* Next, wait for next message */ p_cb->rcv_state = H4_RX_MSGTYPE_ST; } } break; case H4_RX_IGNORE_ST: /* Ignore reset of packet */ p_cb->rcv_len--; /* Check if we read in entire message yet */ if (p_cb->rcv_len == 0) { /* Next, wait for next message */ p_cb->rcv_state = H4_RX_MSGTYPE_ST; } break; } /* If we received entire message, then send it to the task */ if (msg_received) { uint8_t intercepted = FALSE; /* generate snoop trace message */ /* ACL packet tracing had done in acl_rx_frame_end_chk() */ if (p_cb->p_rcv_msg->event != MSG_HC_TO_STACK_HCI_ACL) btsnoop_capture(p_cb->p_rcv_msg, TRUE); if (p_cb->p_rcv_msg->event == MSG_HC_TO_STACK_HCI_EVT) intercepted = internal_event_intercept(); if ((bt_hc_cbacks) && (intercepted == FALSE)) { bt_hc_cbacks->data_ind((TRANSAC) p_cb->p_rcv_msg, \ (char *) (p_cb->p_rcv_msg + 1), \ p_cb->p_rcv_msg->len + BT_HC_HDR_SIZE); } p_cb->p_rcv_msg = NULL; } } return (bytes_read); } /******************************************************************************* ** ** Function hci_h4_send_int_cmd ** ** Description Place the internal commands (issued internally by vendor lib) ** in the tx_q. ** ** Returns TRUE/FALSE ** *******************************************************************************/ uint8_t hci_h4_send_int_cmd(uint16_t opcode, HC_BT_HDR *p_buf, \ tINT_CMD_CBACK p_cback) { if (h4_cb.int_cmd_rsp_pending > INT_CMD_PKT_MAX_COUNT) { ALOGE( \ "Allow only %d outstanding internal commands at a time [Reject 0x%04X]"\ , INT_CMD_PKT_MAX_COUNT, opcode); return FALSE; } h4_cb.int_cmd_rsp_pending++; h4_cb.int_cmd[h4_cb.int_cmd_wrt_idx].opcode = opcode; h4_cb.int_cmd[h4_cb.int_cmd_wrt_idx].cback = p_cback; h4_cb.int_cmd_wrt_idx = ((h4_cb.int_cmd_wrt_idx+1) & INT_CMD_PKT_IDX_MASK); /* stamp signature to indicate an internal command */ p_buf->layer_specific = opcode; utils_enqueue(&tx_q, (void *) p_buf); bthc_signal_event(HC_EVENT_TX); return TRUE; } /******************************************************************************* ** ** Function hci_h4_get_acl_data_length ** ** Description Issue HCI_READ_BUFFER_SIZE command to retrieve Controller's ** ACL data length setting ** ** Returns None ** *******************************************************************************/ void hci_h4_get_acl_data_length(void) { HC_BT_HDR *p_buf = NULL; uint8_t *p, ret; if (bt_hc_cbacks) { p_buf = (HC_BT_HDR *) bt_hc_cbacks->alloc(BT_HC_HDR_SIZE + \ HCI_CMD_PREAMBLE_SIZE); } if (p_buf) { p_buf->event = MSG_STACK_TO_HC_HCI_CMD; p_buf->offset = 0; p_buf->layer_specific = 0; p_buf->len = HCI_CMD_PREAMBLE_SIZE; p = (uint8_t *) (p_buf + 1); UINT16_TO_STREAM(p, HCI_READ_BUFFER_SIZE); *p = 0; if ((ret = hci_h4_send_int_cmd(HCI_READ_BUFFER_SIZE, p_buf, \ get_acl_data_length_cback)) == FALSE) { bt_hc_cbacks->dealloc((TRANSAC) p_buf, (char *) (p_buf + 1)); } else return; } if (bt_hc_cbacks) { ALOGE("vendor lib postload aborted"); bt_hc_cbacks->postload_cb(NULL, BT_HC_POSTLOAD_FAIL); } } /****************************************************************************** ** HCI H4 Services interface table ******************************************************************************/ const tHCI_IF hci_h4_func_table = { hci_h4_init, hci_h4_cleanup, hci_h4_send_msg, hci_h4_send_int_cmd, hci_h4_get_acl_data_length, hci_h4_receive_msg };