蓝牙协议栈接收数据包流程0

蓝牙接收数据包流程

//底层数据包接收的源头 大约在此处
//再上去就是 监控 fd的守护进程了
void H4Protocol::OnDataReady( int fd )    

hci_packetizer_.OnDataReady(fd, hci_packet_type_);

void HciPacketizer::OnDataReady( int fd, HciPacketType packet_type ) 
{

    //ALOGE( "HciPacketizer::OnDataReady state_ = %x", state_ );
    
    switch (state_) {
      case HCI_PREAMBLE: {

      //ALOGE( "bytes_read_ = %x", bytes_read_ );
        
      ssize_t bytes_read = TEMP_FAILURE_RETRY(
          read(fd, preamble_ + bytes_read_,
               preamble_size_for_type[packet_type] - bytes_read_));
      if (bytes_read == 0) {
        // This is only expected if the UART got closed when shutting down.
        ALOGE("%s: Unexpected EOF reading the header!", __func__);
        sleep(5);  // Expect to be shut down within 5 seconds.
        return;
      }
      if (bytes_read < 0) {
        LOG_ALWAYS_FATAL("%s: Read header error: %s", __func__,
                         strerror(errno));
      }

      //ALOGE( "bytes_read = %x", bytes_read );
      bytes_read_ += bytes_read;
      //ALOGE( "bytes_read_ = %x", bytes_read_ );
      if (bytes_read_ == preamble_size_for_type[packet_type]) {
        size_t packet_length = HciGetPacketLengthForType(packet_type, preamble_);
        packet_.resize(preamble_size_for_type[packet_type] + packet_length);
        memcpy(packet_.data(), preamble_, preamble_size_for_type[packet_type]);
        bytes_remaining_ = packet_length;
        state_ = HCI_PAYLOAD;
        bytes_read_ = 0;
      }
      break;
    }

    case HCI_PAYLOAD: {
      ssize_t bytes_read = TEMP_FAILURE_RETRY(read(
          fd,
          packet_.data() + preamble_size_for_type[packet_type] + bytes_read_,
          bytes_remaining_));
      if (bytes_read == 0) {
        // This is only expected if the UART got closed when shutting down.
        ALOGE("%s: Unexpected EOF reading the payload!", __func__);
        sleep(5);  // Expect to be shut down within 5 seconds.
        return;
      }
      if (bytes_read < 0) {
        LOG_ALWAYS_FATAL("%s: Read payload error: %s", __func__,
                         strerror(errno));
      }
      bytes_remaining_ -= bytes_read;
      bytes_read_ += bytes_read;
      if (bytes_remaining_ == 0) {

        //output_buff((char*)packet_.data(), bytes_read_);

        ALOGE("get a packet data from uart" );

        macdbg_dmphex_kernel((const char*)packet_.data(), bytes_read_);

        //ALOGE("packet_ready_cb_.0 = %x", (unsigned int)&packet_ready_cb_ );
        packet_ready_cb_();
        //此处是关键 1
        //ALOGE("packet_ready_cb_.1 = %p", (void *)&packet_ready_cb_ );
        state_ = HCI_PREAMBLE;
        bytes_read_ = 0;
      }
      break;
    }
  }
}

//此处是关键 1 回调的就是这个函数
void H4Protocol::OnPacketReady() 

void H4Protocol::OnPacketReady() 
{
    ALOGE("in %s", __func__);

    //ALOGE("OnPacketReady.1 = %x", (unsigned int)(void (android::hardware::bluetooth::hci::H4Protocol::*)())(H4Protocol::OnPacketReady) );
    

    //android::CallStack    stack;     
    //stack.update();    
    //stack.log("callstack");

    ALOGE( "H4Protocol hci_packet_type_ = %x", hci_packet_type_ );

     //bt_hci  : hciEventReceived
     //07-09 16:30:41.408  2424  2775 I bt_hci  : hci_event_received

  switch (hci_packet_type_) {
    case HCI_PACKET_TYPE_EVENT:
      event_cb_(hci_packetizer_.GetPacket());
      //此处关键点2
      break;
    case HCI_PACKET_TYPE_ACL_DATA:
      acl_cb_(hci_packetizer_.GetPacket());
      break;
    case HCI_PACKET_TYPE_SCO_DATA:
      sco_cb_(hci_packetizer_.GetPacket());
      break;
    default:
#ifndef XRADIO_BLUETOOTH
      LOG_ALWAYS_FATAL("%s: Unimplemented packet type %d", __func__,
                       static_cast<int>(hci_packet_type_));
#else
      break;
#endif
  }
  
  
  
Bluetooth_hci.cc
  bool rc = VendorInterface::Initialize(
      [cb](bool status) {
        auto hidl_status = cb->initializationComplete(
            status ? Status::SUCCESS : Status::INITIALIZATION_ERROR);
        if (!hidl_status.isOk()) {
          ALOGE("VendorInterface -> Unable to call initializationComplete()");
        }
      },
      [cb](const hidl_vec<uint8_t>& packet) {

      //此处关键点2   event_cb_
      ALOGE("VendorInterface -> Unable to call hciEventReceived(1)");
        auto hidl_status = cb->hciEventReceived(packet);
        //此处关键点3   
        //由日志可以看出 
        bluetooth     1714     1   18292   4616 0                   0 S android.hardware.bluetooth@1.0-service
        bluetooth     2430  1695 1435500  96972 0                   0 S com.android.bluetooth
        跨进程调用 从hal层 调用 
07-09 18:30:44.974  1714  2882 E android.hardware.bluetooth@1.0-impl: VendorInterface -> Unable to call hciEventReceived(1)
07-09 18:30:44.974  2430  2767 I bt_hci  : hciEventReceived
07-09 18:30:44.974  2430  2767 E bt_hci  : get a packet data from uartxxx
07-09 18:30:44.974  2430  2767 E bt_hci  : data.size() = 6
07-09 18:30:44.974  2430  2767 E bt_hci  : BT_HDR_SIZE = 8
07-09 18:30:44.975  2430  2767 E bt_hci  : packet_size = e
07-09 18:30:44.975  2430  2767 E bt_hci  : 0    0e 04 05 52 0c 00       ...R..
07-09 18:30:44.975  2430  2767 I bt_hci  : hci_event_received
07-09 18:30:44.975  1714  2882 E android.hardware.bluetooth@1.0-impl: VendorInterface -> Unable to call hciEventReceived(2)

        ALOGE("VendorInterface -> Unable to call hciEventReceived(2)");
        if (!hidl_status.isOk()) {
          ALOGE("VendorInterface -> Unable to call hciEventReceived(3)");
        }
      },
      [cb](const hidl_vec<uint8_t>& packet) {
        auto hidl_status = cb->aclDataReceived(packet);
        if (!hidl_status.isOk()) {
          ALOGE("VendorInterface -> Unable to call aclDataReceived()");
        }
      },
      [cb](const hidl_vec<uint8_t>& packet) {
        auto hidl_status = cb->scoDataReceived(packet);
        if (!hidl_status.isOk()) {
          ALOGE("VendorInterface -> Unable to call scoDataReceived()");
        }
      });
      
      

//此处关键点3  
//Hci_layer_android.cc
 Return<void> hciEventReceived(const hidl_vec<uint8_t>& event) {

    LOG_INFO(LOG_TAG, "%s", __func__);
    
    BT_HDR* packet = WrapPacketAndCopy(MSG_HC_TO_STACK_HCI_EVT, event);
    //构造数据包 packet
    hci_event_received(FROM_HERE, packet);
    return Void();
  }
  

//hci_layer.cc
void hci_event_received(const tracked_objects::Location& from_here,
                        BT_HDR* packet) {
  btsnoop->capture(packet, true);

  LOG_INFO(LOG_TAG, "%s", __func__);

  if (!filter_incoming_event(packet)) {
    send_data_upwards.Run(from_here, packet);
  }
}

static void set_data_cb(
    base::Callback<void(const tracked_objects::Location&, BT_HDR*)>
        send_data_cb) {
  send_data_upwards = std::move(send_data_cb);
}

void bte_main_boot_entry(void) {
  module_init(get_module(INTEROP_MODULE));

  hci = hci_layer_get_interface();
  if (!hci) {
    LOG_ERROR(LOG_TAG, "%s could not get hci layer interface.", __func__);
    return;
  }

  hci->set_data_cb(base::Bind(&post_to_hci_message_loop));

  module_init(get_module(STACK_CONFIG_MODULE));
}

void post_to_hci_message_loop(const tracked_objects::Location& from_here,
                              BT_HDR* p_msg) {
  base::MessageLoop* hci_message_loop = get_message_loop();
  if (!hci_message_loop || !hci_message_loop->task_runner().get()) {
    LOG_ERROR(LOG_TAG, "%s: HCI message loop not running, accessed from %s",
              __func__, from_here.ToString().c_str());
    return;
  }

  hci_message_loop->task_runner()->PostTask(
      from_here, base::Bind(&btu_hci_msg_process, p_msg));
}

void btu_hci_msg_process( BT_HDR* p_msg )       
{
    //LOG(INFO) << "btu_hci_msg_process";
    //LOG(INFO) << "p_msg->event = "<< p_msg->event;

    
  /* Determine the input message type. */
  switch (p_msg->event & BT_EVT_MASK) {
    case BT_EVT_TO_BTU_HCI_ACL:
      /* All Acl Data goes to L2CAP */
      l2c_rcv_acl_data(p_msg);
      break;

    case BT_EVT_TO_BTU_L2C_SEG_XMIT:
      /* L2CAP segment transmit complete */
      l2c_link_segments_xmitted(p_msg);
      break;

    case BT_EVT_TO_BTU_HCI_SCO:
#if (BTM_SCO_INCLUDED == TRUE)
      btm_route_sco_data(p_msg);
      break;
#endif

    case BT_EVT_TO_BTU_HCI_EVT:
      btu_hcif_process_event((uint8_t)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
      osi_free(p_msg);
      break;

    case BT_EVT_TO_BTU_HCI_CMD:
      btu_hcif_send_cmd((uint8_t)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
      break;

    default:
      osi_free(p_msg);
      break;
  }
}

大概意思如下:
串口上传数据包大概流程
由内核态的驱动程序 提供给 /dev/ttyS1 数据包,通过的是tty线路规程
发送一个信号通知用户态接收数据包
用户态进程监控 打开/dev/ttyS1的文件描述符fd
用户态解除阻塞等状态
就到了本文开头的位置
然后就是几个关键点的回调
一步步回调到蓝牙的协议栈里面去
具体细节还待分析
现在只是抓个主要脉络和框架

至于数据包的下发流程 基本是这个流程的逆过程
由hci接口 干到内核态去的
跟踪这个流程的关键是 用 macdbg_dmphex_kernel
打印各个节点的数据包的内容
以一个数据包的传递过程 来跟踪代码流程。