Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a1e1a440 authored by Chris Manton's avatar Chris Manton
Browse files

legacy: Delete all of hci_layer_get_interface_legacy 

Including all internally linked functions

Bug: 197150934
Tag: #refactor
Test: gd/cert/run

Change-Id: I59c1545491cd95117ff1adadc8f71913f7853efb
parent b1a986f3

system/hci/src/hci_layer.cc

+0 −131
Original line number Diff line number Diff line
@@ -133,10 +133,6 @@ static void hci_timeout_abort(void); 
static void event_finish_startup(void* context);

static void startup_timer_expired(void* context);



static void enqueue_command(waiting_command_t* wait_entry);

static void event_command_ready(waiting_command_t* wait_entry);

static void enqueue_packet(void* packet);

static void event_packet_ready(void* packet);

static void command_timed_out(void* context);



static void update_command_response_timer(void);
@@ -305,64 +301,7 @@ EXPORT_SYMBOL extern const module_t hci_module = { 
    .clean_up = NULL,

    .dependencies = {BTSNOOP_MODULE, NULL}};



// Interface functions



static void set_data_cb(

    base::Callback<void(const base::Location&, BT_HDR*)> send_data_cb) {

  send_data_upwards = std::move(send_data_cb);

}



static void transmit_command(BT_HDR* command,

                             command_complete_cb complete_callback,

                             command_status_cb status_callback, void* context) {

  waiting_command_t* wait_entry = reinterpret_cast<waiting_command_t*>(

      osi_calloc(sizeof(waiting_command_t)));



  uint8_t* stream = command->data + command->offset;

  STREAM_TO_UINT16(wait_entry->opcode, stream);

  wait_entry->complete_callback = complete_callback;

  wait_entry->status_callback = status_callback;

  wait_entry->command = command;

  wait_entry->context = context;



  // Store the command message type in the event field

  // in case the upper layer didn't already

  command->event = MSG_STACK_TO_HC_HCI_CMD;



  enqueue_command(wait_entry);

}



static future_t* transmit_command_futured(BT_HDR* command) {

  waiting_command_t* wait_entry = reinterpret_cast<waiting_command_t*>(

      osi_calloc(sizeof(waiting_command_t)));

  future_t* future = future_new();



  uint8_t* stream = command->data + command->offset;

  STREAM_TO_UINT16(wait_entry->opcode, stream);

  wait_entry->complete_future = future;

  wait_entry->command = command;



  // Store the command message type in the event field

  // in case the upper layer didn't already

  command->event = MSG_STACK_TO_HC_HCI_CMD;



  enqueue_command(wait_entry);

  return future;

}



static void transmit_downward(uint16_t type, void* data) {

  if (type == MSG_STACK_TO_HC_HCI_CMD) {

    // TODO(zachoverflow): eliminate this call

    transmit_command((BT_HDR*)data, NULL, NULL, NULL);

    LOG_WARN("%s legacy transmit of command. Use transmit_command instead.",

             __func__);

  } else {

    enqueue_packet(data);

  }

}



// Start up functions



static void event_finish_startup(UNUSED_ATTR void* context) {

  LOG_INFO("%s", __func__);

  std::lock_guard<std::recursive_timed_mutex> lock(
@@ -391,53 +330,6 @@ static void startup_timer_expired(UNUSED_ATTR void* context) { 
  abort();

}



// Command/packet transmitting functions

static void enqueue_command(waiting_command_t* wait_entry) {

  base::Closure callback = base::Bind(&event_command_ready, wait_entry);



  std::lock_guard<std::mutex> command_credits_lock(command_credits_mutex);

  if (command_credits > 0) {

    if (!hci_thread.DoInThread(FROM_HERE, std::move(callback))) {

      // HCI Layer was shut down or not running

      buffer_allocator->free(wait_entry->command);

      osi_free(wait_entry);

      return;

    }

    command_credits--;

  } else {

    command_queue.push(std::move(callback));

  }

}



static void event_command_ready(waiting_command_t* wait_entry) {

  {

    /// Move it to the list of commands awaiting response

    std::lock_guard<std::recursive_timed_mutex> lock(

        commands_pending_response_mutex);

    wait_entry->timestamp = std::chrono::steady_clock::now();

    list_append(commands_pending_response, wait_entry);

  }

  // Send it off

  packet_fragmenter->fragment_and_dispatch(wait_entry->command);



  update_command_response_timer();

}



static void enqueue_packet(void* packet) {

  if (!hci_thread.DoInThread(FROM_HERE,

                             base::Bind(&event_packet_ready, packet))) {

    // HCI Layer was shut down or not running

    buffer_allocator->free(packet);

    return;

  }

}



static void event_packet_ready(void* pkt) {

  // The queue may be the command queue or the packet queue, we don't care

  BT_HDR* packet = (BT_HDR*)pkt;

  packet_fragmenter->fragment_and_dispatch(packet);

}



// Callback for the fragmenter to send a fragment

static void transmit_fragment(BT_HDR* packet, bool send_transmit_finished) {

  btsnoop->capture(packet, false);
@@ -858,19 +750,6 @@ static bool filter_bqr_event(int16_t bqr_parameter_length, 
  return intercepted;

}



static void init_layer_interface() {

  if (!interface_created) {

    // It's probably ok for this to live forever. It's small and

    // there's only one instance of the hci interface.



    interface.set_data_cb = set_data_cb;

    interface.transmit_command = transmit_command;

    interface.transmit_command_futured = transmit_command_futured;

    interface.transmit_downward = transmit_downward;

    interface_created = true;

  }

}



void hci_layer_cleanup_interface() {

  if (interface_created) {

    send_data_upwards.Reset();
@@ -889,16 +768,6 @@ const hci_t* hci_layer_get_interface(); 
}  // namespace shim

}  // namespace bluetooth



const hci_t* hci_layer_get_interface_legacy() {

  buffer_allocator = buffer_allocator_get_interface();

  btsnoop = btsnoop_get_interface();

  packet_fragmenter = packet_fragmenter_get_interface();



  init_layer_interface();



  return &interface;

}



const hci_t* hci_layer_get_interface() {

  return bluetooth::shim::hci_layer_get_interface();

}