ble_hci_ra8_ble.c

Go to the documentation of this file.

 
#include "ble_hci_ra8_ble.h"
 
#include <stdint.h>
#include <string.h>
 
#include "nimble_transport_stubs.h"
#include "ra8_attributes.h"
#include "ra8_ble.h"
#include "ra8_err.h"
 
/* =============================================================================
 * Adapter-private state
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ble_hci_ra8_ble_state_idle    = 0U, 
  k_ble_hci_ra8_ble_state_running = 1U, 
} ble_hci_ra8_ble_state_t;

typedef enum : uint8_t {
  k_ble_hci_evt_off_code   = 0U, 
  k_ble_hci_evt_off_len    = 1U, 
  k_ble_hci_evt_off_params = 2U, 
  k_ble_hci_evt_header_len = 2U, 
} ble_hci_ra8_ble_evt_layout_t;

typedef enum : uint8_t {
  k_ble_hci_acl_off_handle_lo = 0U, 
  k_ble_hci_acl_off_handle_hi = 1U, 
  k_ble_hci_acl_off_len_lo    = 2U, 
  k_ble_hci_acl_off_len_hi    = 3U, 
  k_ble_hci_acl_off_payload   = 4U, 
  k_ble_hci_acl_header_len    = 4U, 
} ble_hci_ra8_ble_acl_layout_t;

typedef enum : uint8_t {
  k_ble_hci_shift_byte = 8U, 
} ble_hci_ra8_ble_bits_t;

typedef enum : uint32_t {
  k_ble_hci_mask_byte = 0xFFU, 
} ble_hci_ra8_ble_masks_t;

static ble_hci_ra8_ble_state_t s_state = k_ble_hci_ra8_ble_state_idle;
 
/* =============================================================================
 * Private callbacks: ra8_ble -> NimBLE host
 * =============================================================================
 */

RA8_INTERNAL static void
internal_event_cb(void* ctx, uint8_t evt_code, const uint8_t* params, uint8_t params_len)
{
  (void)ctx;
  if (s_state != k_ble_hci_ra8_ble_state_running) {
    return;
  }
  if (params == nullptr && params_len > 0U) {
    return;
  }
 
  uint8_t* hci_evt = (uint8_t*)ble_transport_alloc_evt(0);
  if (hci_evt == nullptr) {
    /* Transient OOM -- the controller will retry. */
    return;
  }
 
  hci_evt[k_ble_hci_evt_off_code] = evt_code;
  hci_evt[k_ble_hci_evt_off_len]  = params_len;
  if (params_len > 0U) {
    (void)memcpy(&hci_evt[k_ble_hci_evt_off_params], params, params_len);
  }
 
  (void)ble_transport_to_hs_evt(hci_evt);
}

RA8_INTERNAL static void
internal_acl_cb(void* ctx, uint16_t handle, const uint8_t* payload, uint16_t len)
{
  (void)ctx;
  if (s_state != k_ble_hci_ra8_ble_state_running) {
    return;
  }
  if (payload == nullptr && len > 0U) {
    return;
  }
 
  struct os_mbuf* om = ble_transport_alloc_acl_from_ll();
  if (om == nullptr) {
    return;
  }
 
  uint8_t hdr[k_ble_hci_acl_header_len];
  hdr[k_ble_hci_acl_off_handle_lo] = (uint8_t)(handle & k_ble_hci_mask_byte);
  hdr[k_ble_hci_acl_off_handle_hi] =
    (uint8_t)((handle >> k_ble_hci_shift_byte) & k_ble_hci_mask_byte);
  hdr[k_ble_hci_acl_off_len_lo] = (uint8_t)(len & k_ble_hci_mask_byte);
  hdr[k_ble_hci_acl_off_len_hi] = (uint8_t)((len >> k_ble_hci_shift_byte) & k_ble_hci_mask_byte);
 
  if (os_mbuf_append(om, hdr, (uint16_t)k_ble_hci_acl_header_len) != 0) {
    (void)os_mbuf_free_chain(om);
    return;
  }
  if (len > 0U && os_mbuf_append(om, payload, len) != 0) {
    (void)os_mbuf_free_chain(om);
    return;
  }
 
  (void)ble_transport_to_hs_acl(om);
}
 
/* =============================================================================
 * Public lifecycle
 * =============================================================================
 */
 
/* Ble hci ra ble init -- see implementation for details. */
ra8_err_t ble_hci_ra8_ble_init(void)
{
  if (ra8_ble_attach_event_handler(internal_event_cb, nullptr) != k_ra8_ok) {
    return k_ra8_err_not_initialized;
  }
  if (ra8_ble_attach_acl_handler(internal_acl_cb, nullptr) != k_ra8_ok) {
    return k_ra8_err_not_initialized;
  }
  s_state = k_ble_hci_ra8_ble_state_running;
  return k_ra8_ok;
}
 
/* Ble hci ra ble deinit -- see implementation for details. */
ra8_err_t ble_hci_ra8_ble_deinit(void)
{
  s_state = k_ble_hci_ra8_ble_state_idle;
  (void)ra8_ble_attach_event_handler(nullptr, nullptr);
  (void)ra8_ble_attach_acl_handler(nullptr, nullptr);
  return k_ra8_ok;
}
 
/* =============================================================================
 * NimBLE LL-side transport hooks (host -> controller)
 * =============================================================================
 *
 * The NimBLE transport core calls these *_impl() entry points -- the
 * outer ``ble_transport_to_ll_cmd`` / ``ble_transport_to_ll_acl``
 * wrappers in libs/third_party/nimble/nimble/transport/ resolve here.
 * ``ble_transport_ll_init`` is invoked from the upstream
 * ``ble_transport_init`` so we use it to hot-attach our callbacks
 * even when the app skipped the explicit ``ble_hci_ra8_ble_init``.
 */

void ble_transport_ll_init(void)
{
  if (s_state != k_ble_hci_ra8_ble_state_running) {
    (void)ble_hci_ra8_ble_init();
  }
}
 
/* Ble transport to ll cmd impl -- see implementation for details. */
int ble_transport_to_ll_cmd_impl(void* buf)
{
  if (buf == nullptr) {
    return -1;
  }
  const uint8_t* bytes = (const uint8_t*)buf;
  const uint16_t opcode =
    (uint16_t)((uint16_t)bytes[0] | ((uint16_t)bytes[1] << k_ble_hci_shift_byte));
  const uint8_t  params_len = bytes[2];
  const uint8_t* params     = (params_len == 0U) ? nullptr : &bytes[3];
 
  const ra8_err_t err = ra8_ble_hci_send_command(opcode, params, params_len);
  ble_transport_free(buf);
  return (err == k_ra8_ok) ? 0 : -1;
}
 
/* Ble transport to ll acl impl -- see implementation for details. */
int ble_transport_to_ll_acl_impl(struct os_mbuf* om)
{
  if (om == nullptr) {
    return -1;
  }
  const uint16_t total = os_mbuf_len(om);
  if (total < (uint16_t)k_ble_hci_acl_header_len) {
    (void)os_mbuf_free_chain(om);
    return -1;
  }
  if (total > (uint16_t)k_ble_hci_ra8_ble_acl_buf_max) {
    (void)os_mbuf_free_chain(om);
    return -1;
  }
 
  uint8_t flat[k_ble_hci_ra8_ble_acl_buf_max];
  if (os_mbuf_copydata(om, 0, (int)total, flat) != 0) {
    (void)os_mbuf_free_chain(om);
    return -1;
  }
  (void)os_mbuf_free_chain(om);
 
  const uint16_t handle =
    (uint16_t)((uint16_t)flat[k_ble_hci_acl_off_handle_lo] |
               ((uint16_t)flat[k_ble_hci_acl_off_handle_hi] << k_ble_hci_shift_byte));
  const uint16_t len =
    (uint16_t)((uint16_t)flat[k_ble_hci_acl_off_len_lo] |
               ((uint16_t)flat[k_ble_hci_acl_off_len_hi] << k_ble_hci_shift_byte));
  if ((uint16_t)(len + (uint16_t)k_ble_hci_acl_header_len) > total) {
    return -1;
  }
 
  const uint8_t*  payload = (len == 0U) ? nullptr : &flat[k_ble_hci_acl_off_payload];
  const ra8_err_t err     = ra8_ble_hci_send_acl_data(handle, payload, len);
  return (err == k_ra8_ok) ? 0 : -1;
}

int ble_transport_to_ll_iso_impl(struct os_mbuf* om)
{
  if (om != nullptr) {
    (void)os_mbuf_free_chain(om);
  }
  return 0;
}