| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| */ |
| |
| #include <assert.h> |
| #include <string.h> |
| #include <stdio.h> |
| #include <errno.h> |
| #include <stdint.h> |
| #include "sysinit/sysinit.h" |
| #include "syscfg/syscfg.h" |
| #include "os/os_cputime.h" |
| #include "bsp/bsp.h" |
| #include "os/os.h" |
| #include "mem/mem.h" |
| #include "hal/hal_gpio.h" |
| #include "hal/hal_spi.h" |
| |
| /* BLE */ |
| #include "nimble/ble.h" |
| #include "nimble/nimble_opt.h" |
| #include "nimble/hci_common.h" |
| #include "nimble/ble_hci_trans.h" |
| |
| #include "transport/emspi/ble_hci_emspi.h" |
| |
| #include "am_mcu_apollo.h" |
| |
| /*** |
| * NOTES: |
| * The emspi HCI transport doesn't use event buffer priorities. All incoming |
| * and outgoing events use buffers from the same pool. |
| * |
| */ |
| |
| #define BLE_HCI_EMSPI_PKT_EVT_COUNT \ |
| (MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT) + \ |
| MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT)) |
| |
| #define BLE_HCI_EMSPI_PKT_NONE 0x00 |
| #define BLE_HCI_EMSPI_PKT_CMD 0x01 |
| #define BLE_HCI_EMSPI_PKT_ACL 0x02 |
| #define BLE_HCI_EMSPI_PKT_EVT 0x04 |
| |
| #define BLE_HCI_EMSPI_CTLR_STATUS_OK 0xc0 |
| #define BLE_HCI_EMSPI_OP_TX 0x42 |
| #define BLE_HCI_EMSPI_OP_RX 0x81 |
| |
| static os_event_fn ble_hci_emspi_event_txrx; |
| |
| static struct os_event ble_hci_emspi_ev_txrx = { |
| .ev_cb = ble_hci_emspi_event_txrx, |
| }; |
| |
| static struct os_eventq ble_hci_emspi_evq; |
| static struct os_task ble_hci_emspi_task; |
| static os_stack_t ble_hci_emspi_stack[MYNEWT_VAL(BLE_HCI_EMSPI_STACK_SIZE)]; |
| |
| static ble_hci_trans_rx_cmd_fn *ble_hci_emspi_rx_cmd_cb; |
| static void *ble_hci_emspi_rx_cmd_arg; |
| |
| static ble_hci_trans_rx_acl_fn *ble_hci_emspi_rx_acl_cb; |
| static void *ble_hci_emspi_rx_acl_arg; |
| |
| static struct os_mempool ble_hci_emspi_evt_hi_pool; |
| static os_membuf_t ble_hci_emspi_evt_hi_buf[ |
| OS_MEMPOOL_SIZE(MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT), |
| MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE)) |
| ]; |
| |
| static struct os_mempool ble_hci_emspi_evt_lo_pool; |
| static os_membuf_t ble_hci_emspi_evt_lo_buf[ |
| OS_MEMPOOL_SIZE(MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT), |
| MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE)) |
| ]; |
| |
| static struct os_mempool ble_hci_emspi_cmd_pool; |
| static os_membuf_t ble_hci_emspi_cmd_buf[ |
| OS_MEMPOOL_SIZE(1, BLE_HCI_TRANS_CMD_SZ) |
| ]; |
| |
| static struct os_mbuf_pool ble_hci_emspi_acl_mbuf_pool; |
| static struct os_mempool_ext ble_hci_emspi_acl_pool; |
| |
| /* |
| * The MBUF payload size must accommodate the HCI data header size plus the |
| * maximum ACL data packet length. The ACL block size is the size of the |
| * mbufs we will allocate. |
| */ |
| #define ACL_BLOCK_SIZE OS_ALIGN(MYNEWT_VAL(BLE_ACL_BUF_SIZE) \ |
| + BLE_MBUF_MEMBLOCK_OVERHEAD \ |
| + BLE_HCI_DATA_HDR_SZ, OS_ALIGNMENT) |
| |
| static os_membuf_t ble_hci_emspi_acl_buf[ |
| OS_MEMPOOL_SIZE(MYNEWT_VAL(BLE_ACL_BUF_COUNT), |
| ACL_BLOCK_SIZE) |
| ]; |
| |
| /** |
| * A packet to be sent over the EMSPI. This can be a command, an event, or ACL |
| * data. |
| */ |
| struct ble_hci_emspi_pkt { |
| STAILQ_ENTRY(ble_hci_emspi_pkt) next; |
| void *data; |
| uint8_t type; |
| }; |
| STAILQ_HEAD(, ble_hci_emspi_pkt) ble_hci_emspi_tx_q; |
| |
| static struct os_mempool ble_hci_emspi_pkt_pool; |
| static os_membuf_t ble_hci_emspi_pkt_buf[ |
| OS_MEMPOOL_SIZE(BLE_HCI_EMSPI_PKT_EVT_COUNT + 1 + |
| MYNEWT_VAL(BLE_HCI_ACL_OUT_COUNT), |
| sizeof (struct ble_hci_emspi_pkt)) |
| ]; |
| |
| static void |
| ble_hci_emspi_rdy_isr(void *arg) |
| { |
| os_eventq_put(&ble_hci_emspi_evq, &ble_hci_emspi_ev_txrx); |
| } |
| |
| static void |
| ble_hci_emspi_initiate_write(void) |
| { |
| hal_gpio_irq_disable(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN)); |
| |
| /* Assert slave select. */ |
| hal_gpio_write(MYNEWT_VAL(BLE_HCI_EMSPI_SS_PIN), 0); |
| |
| /* Wait for controller to indicate ready-to-receive. */ |
| while (!hal_gpio_read(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN))) { } |
| } |
| |
| static void |
| ble_hci_emspi_terminate_write(void) |
| { |
| const uint64_t rdy_mask = |
| AM_HAL_GPIO_BIT(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN)); |
| os_sr_t sr; |
| |
| am_hal_gpio_int_clear(rdy_mask); |
| |
| /* Deassert slave select. */ |
| hal_gpio_write(MYNEWT_VAL(BLE_HCI_EMSPI_SS_PIN), 1); |
| |
| OS_ENTER_CRITICAL(sr); |
| hal_gpio_irq_enable(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN)); |
| |
| if (hal_gpio_read(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN))) { |
| am_hal_gpio_int_set(rdy_mask); |
| } |
| |
| OS_EXIT_CRITICAL(sr); |
| } |
| |
| static int |
| ble_hci_emspi_write_hdr(uint8_t first_byte, uint8_t *out_buf_size) |
| { |
| const uint8_t hdr[2] = { first_byte, 0x00 }; |
| uint8_t rx[2]; |
| int rc; |
| |
| /* Send command header. */ |
| rc = hal_spi_txrx(MYNEWT_VAL(BLE_HCI_EMSPI_SPI_NUM), (void *)hdr, rx, 2); |
| if (rc != 0) { |
| return rc; |
| } |
| |
| /* Check for "OK" status. */ |
| if (rx[0] != BLE_HCI_EMSPI_CTLR_STATUS_OK) { |
| return BLE_ERR_HW_FAIL; |
| } |
| |
| *out_buf_size = rx[1]; |
| return 0; |
| } |
| |
| /** |
| * Transmits a chunk of bytes to the controller. |
| */ |
| static int |
| ble_hci_emspi_tx_chunk(const uint8_t *data, int len, int *out_bytes_txed) |
| { |
| uint8_t buf_size; |
| int rc; |
| |
| /* Silence spurious "may be used uninitialized" warning. */ |
| *out_bytes_txed = 0; |
| |
| ble_hci_emspi_initiate_write(); |
| |
| rc = ble_hci_emspi_write_hdr(BLE_HCI_EMSPI_OP_TX, &buf_size); |
| if (rc != 0) { |
| goto done; |
| } |
| |
| if (buf_size == 0) { |
| rc = 0; |
| goto done; |
| } |
| |
| if (buf_size < len) { |
| len = buf_size; |
| } |
| rc = hal_spi_txrx(MYNEWT_VAL(BLE_HCI_EMSPI_SPI_NUM), (void *)data, NULL, |
| len); |
| if (rc != 0) { |
| goto done; |
| } |
| *out_bytes_txed = len; |
| |
| done: |
| ble_hci_emspi_terminate_write(); |
| return rc; |
| } |
| |
| /** |
| * Transmits a full command or ACL data packet to the controller. |
| */ |
| static int |
| ble_hci_emspi_tx(const uint8_t *data, int len) |
| { |
| int bytes_txed; |
| int rc; |
| |
| while (len > 0) { |
| rc = ble_hci_emspi_tx_chunk(data, len, &bytes_txed); |
| if (rc != 0) { |
| goto done; |
| } |
| |
| data += bytes_txed; |
| len -= bytes_txed; |
| } |
| |
| rc = 0; |
| |
| done: |
| return rc; |
| } |
| |
| /** |
| * Reads the specified number of bytes from the controller. |
| */ |
| static int |
| ble_hci_emspi_rx(uint8_t *data, int max_len) |
| { |
| uint8_t buf_size; |
| int rc; |
| |
| ble_hci_emspi_initiate_write(); |
| |
| rc = ble_hci_emspi_write_hdr(BLE_HCI_EMSPI_OP_RX, &buf_size); |
| if (rc != 0) { |
| goto done; |
| } |
| |
| if (buf_size > max_len) { |
| buf_size = max_len; |
| } |
| |
| rc = hal_spi_txrx(MYNEWT_VAL(BLE_HCI_EMSPI_SPI_NUM), NULL, data, buf_size); |
| if (rc != 0) { |
| rc = BLE_ERR_HW_FAIL; |
| goto done; |
| } |
| |
| done: |
| ble_hci_emspi_terminate_write(); |
| return rc; |
| } |
| |
| /** |
| * Allocates a buffer (mbuf) for ACL operation. |
| * |
| * @return The allocated buffer on success; |
| * NULL on buffer exhaustion. |
| */ |
| static struct os_mbuf * |
| ble_hci_trans_acl_buf_alloc(void) |
| { |
| uint8_t usrhdr_len; |
| |
| #if MYNEWT_VAL(BLE_HS_FLOW_CTRL) |
| usrhdr_len = BLE_MBUF_HS_HDR_LEN; |
| #else |
| usrhdr_len = 0; |
| #endif |
| |
| return os_mbuf_get_pkthdr(&ble_hci_emspi_acl_mbuf_pool, usrhdr_len); |
| } |
| |
| /** |
| * Transmits an ACL data packet to the controller. The caller relinquishes the |
| * specified mbuf, regardless of return status. |
| */ |
| static int |
| ble_hci_emspi_acl_tx(struct os_mbuf *om) |
| { |
| struct ble_hci_emspi_pkt *pkt; |
| os_sr_t sr; |
| |
| /* If this packet is zero length, just free it */ |
| if (OS_MBUF_PKTLEN(om) == 0) { |
| os_mbuf_free_chain(om); |
| return 0; |
| } |
| |
| pkt = os_memblock_get(&ble_hci_emspi_pkt_pool); |
| if (pkt == NULL) { |
| os_mbuf_free_chain(om); |
| return BLE_ERR_MEM_CAPACITY; |
| } |
| |
| pkt->type = BLE_HCI_EMSPI_PKT_ACL; |
| pkt->data = om; |
| |
| OS_ENTER_CRITICAL(sr); |
| STAILQ_INSERT_TAIL(&ble_hci_emspi_tx_q, pkt, next); |
| OS_EXIT_CRITICAL(sr); |
| |
| os_eventq_put(&ble_hci_emspi_evq, &ble_hci_emspi_ev_txrx); |
| |
| return 0; |
| } |
| |
| /** |
| * Transmits a command packet to the controller. The caller relinquishes the |
| * specified buffer, regardless of return status. |
| */ |
| static int |
| ble_hci_emspi_cmdevt_tx(uint8_t *cmd_buf, uint8_t pkt_type) |
| { |
| struct ble_hci_emspi_pkt *pkt; |
| os_sr_t sr; |
| |
| pkt = os_memblock_get(&ble_hci_emspi_pkt_pool); |
| if (pkt == NULL) { |
| ble_hci_trans_buf_free(cmd_buf); |
| return BLE_ERR_MEM_CAPACITY; |
| } |
| |
| pkt->type = pkt_type; |
| pkt->data = cmd_buf; |
| |
| OS_ENTER_CRITICAL(sr); |
| STAILQ_INSERT_TAIL(&ble_hci_emspi_tx_q, pkt, next); |
| OS_EXIT_CRITICAL(sr); |
| |
| os_eventq_put(&ble_hci_emspi_evq, &ble_hci_emspi_ev_txrx); |
| |
| return 0; |
| } |
| |
| static int |
| ble_hci_emspi_tx_flat(const uint8_t *data, int len) |
| { |
| int rc; |
| |
| rc = ble_hci_emspi_tx(data, len); |
| return rc; |
| } |
| |
| static int |
| ble_hci_emspi_tx_pkt_type(uint8_t pkt_type) |
| { |
| return ble_hci_emspi_tx_flat(&pkt_type, 1); |
| } |
| |
| static int |
| ble_hci_emspi_tx_cmd(const uint8_t *data) |
| { |
| int len; |
| int rc; |
| |
| rc = ble_hci_emspi_tx_pkt_type(BLE_HCI_EMSPI_PKT_CMD); |
| if (rc != 0) { |
| return rc; |
| } |
| |
| len = data[2] + BLE_HCI_CMD_HDR_LEN; |
| rc = ble_hci_emspi_tx_flat(data, len); |
| if (rc != 0) { |
| return rc; |
| } |
| |
| return 0; |
| } |
| |
| static int |
| ble_hci_emspi_tx_acl(struct os_mbuf *om) |
| { |
| struct os_mbuf *cur; |
| int rc; |
| |
| rc = ble_hci_emspi_tx_pkt_type(BLE_HCI_EMSPI_PKT_ACL); |
| if (rc != 0) { |
| return rc; |
| } |
| |
| cur = om; |
| while (cur != NULL) { |
| rc = ble_hci_emspi_tx(cur->om_data, cur->om_len); |
| if (rc != 0) { |
| break; |
| } |
| |
| cur = SLIST_NEXT(cur, om_next); |
| } |
| |
| return rc; |
| } |
| |
| static struct ble_hci_emspi_pkt * |
| ble_hci_emspi_pull_next_tx(void) |
| { |
| struct ble_hci_emspi_pkt *pkt; |
| os_sr_t sr; |
| |
| OS_ENTER_CRITICAL(sr); |
| pkt = STAILQ_FIRST(&ble_hci_emspi_tx_q); |
| if (pkt != NULL) { |
| STAILQ_REMOVE(&ble_hci_emspi_tx_q, pkt, ble_hci_emspi_pkt, next); |
| } |
| OS_EXIT_CRITICAL(sr); |
| |
| return pkt; |
| } |
| |
| static int |
| ble_hci_emspi_tx_pkt(void) |
| { |
| struct ble_hci_emspi_pkt *pkt; |
| int rc; |
| |
| pkt = ble_hci_emspi_pull_next_tx(); |
| if (pkt == NULL) { |
| return -1; |
| } |
| |
| switch (pkt->type) { |
| case BLE_HCI_EMSPI_PKT_CMD: |
| rc = ble_hci_emspi_tx_cmd(pkt->data); |
| ble_hci_trans_buf_free(pkt->data); |
| break; |
| |
| case BLE_HCI_EMSPI_PKT_ACL: |
| rc = ble_hci_emspi_tx_acl(pkt->data); |
| os_mbuf_free_chain(pkt->data); |
| break; |
| |
| default: |
| rc = -1; |
| break; |
| } |
| |
| os_memblock_put(&ble_hci_emspi_pkt_pool, pkt); |
| |
| return rc; |
| } |
| |
| static int |
| ble_hci_emspi_rx_evt(void) |
| { |
| uint8_t *data; |
| uint8_t len; |
| int rc; |
| |
| /* XXX: we should not assert if host cannot allocate an event. Need |
| * to determine what to do here. |
| */ |
| data = ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_EVT_HI); |
| assert(data != NULL); |
| |
| rc = ble_hci_emspi_rx(data, BLE_HCI_EVENT_HDR_LEN); |
| if (rc != 0) { |
| goto err; |
| } |
| |
| len = data[1]; |
| if (len > 0) { |
| rc = ble_hci_emspi_rx(data + BLE_HCI_EVENT_HDR_LEN, len); |
| if (rc != 0) { |
| goto err; |
| } |
| } |
| |
| assert(ble_hci_emspi_rx_cmd_cb != NULL); |
| ble_hci_emspi_rx_cmd_cb(data, ble_hci_emspi_rx_cmd_arg); |
| if (rc != 0) { |
| goto err; |
| } |
| |
| return 0; |
| |
| err: |
| ble_hci_trans_buf_free(data); |
| return rc; |
| } |
| |
| static int |
| ble_hci_emspi_rx_acl(void) |
| { |
| struct os_mbuf *om; |
| uint16_t len; |
| int rc; |
| |
| /* XXX: we should not assert if host cannot allocate an mbuf. Need to |
| * determine what to do here. |
| */ |
| om = ble_hci_trans_acl_buf_alloc(); |
| assert(om != NULL); |
| |
| rc = ble_hci_emspi_rx(om->om_data, BLE_HCI_DATA_HDR_SZ); |
| if (rc != 0) { |
| goto err; |
| } |
| |
| len = get_le16(om->om_data + 2); |
| if (len > MYNEWT_VAL(BLE_ACL_BUF_SIZE)) { |
| /* |
| * Data portion cannot exceed data length of acl buffer. If it does |
| * this is considered to be a loss of sync. |
| */ |
| rc = BLE_ERR_UNSPECIFIED; |
| goto err; |
| } |
| |
| if (len > 0) { |
| rc = ble_hci_emspi_rx(om->om_data + BLE_HCI_DATA_HDR_SZ, len); |
| if (rc != 0) { |
| goto err; |
| } |
| } |
| |
| OS_MBUF_PKTLEN(om) = BLE_HCI_DATA_HDR_SZ + len; |
| om->om_len = BLE_HCI_DATA_HDR_SZ + len; |
| |
| assert(ble_hci_emspi_rx_cmd_cb != NULL); |
| rc = ble_hci_emspi_rx_acl_cb(om, ble_hci_emspi_rx_acl_arg); |
| if (rc != 0) { |
| goto err; |
| } |
| |
| return 0; |
| |
| err: |
| os_mbuf_free_chain(om); |
| return rc; |
| } |
| |
| /** |
| * @return The type of packet to follow success; |
| * -1 if there is no valid packet to receive. |
| */ |
| static int |
| ble_hci_emspi_rx_pkt(void) |
| { |
| uint8_t pkt_type; |
| int rc; |
| |
| /* XXX: This is awkward; should read the full packet in "one go". */ |
| rc = ble_hci_emspi_rx(&pkt_type, 1); |
| if (rc != 0) { |
| return rc; |
| } |
| |
| switch (pkt_type) { |
| case BLE_HCI_EMSPI_PKT_EVT: |
| return ble_hci_emspi_rx_evt(); |
| |
| case BLE_HCI_EMSPI_PKT_ACL: |
| return ble_hci_emspi_rx_acl(); |
| |
| default: |
| /* XXX */ |
| return -1; |
| } |
| } |
| |
| static void |
| ble_hci_emspi_set_rx_cbs(ble_hci_trans_rx_cmd_fn *cmd_cb, |
| void *cmd_arg, |
| ble_hci_trans_rx_acl_fn *acl_cb, |
| void *acl_arg) |
| { |
| ble_hci_emspi_rx_cmd_cb = cmd_cb; |
| ble_hci_emspi_rx_cmd_arg = cmd_arg; |
| ble_hci_emspi_rx_acl_cb = acl_cb; |
| ble_hci_emspi_rx_acl_arg = acl_arg; |
| } |
| |
| static void |
| ble_hci_emspi_free_pkt(uint8_t type, uint8_t *cmdevt, struct os_mbuf *acl) |
| { |
| switch (type) { |
| case BLE_HCI_EMSPI_PKT_NONE: |
| break; |
| |
| case BLE_HCI_EMSPI_PKT_CMD: |
| case BLE_HCI_EMSPI_PKT_EVT: |
| ble_hci_trans_buf_free(cmdevt); |
| break; |
| |
| case BLE_HCI_EMSPI_PKT_ACL: |
| os_mbuf_free_chain(acl); |
| break; |
| |
| default: |
| assert(0); |
| break; |
| } |
| } |
| |
| /** |
| * Unsupported. This is a host-only transport. |
| */ |
| int |
| ble_hci_trans_ll_evt_tx(uint8_t *cmd) |
| { |
| return BLE_ERR_UNSUPPORTED; |
| } |
| |
| /** |
| * Unsupported. This is a host-only transport. |
| */ |
| int |
| ble_hci_trans_ll_acl_tx(struct os_mbuf *om) |
| { |
| return BLE_ERR_UNSUPPORTED; |
| } |
| |
| /** |
| * Sends an HCI command from the host to the controller. |
| * |
| * @param cmd The HCI command to send. This buffer must be |
| * allocated via ble_hci_trans_buf_alloc(). |
| * |
| * @return 0 on success; |
| * A BLE_ERR_[...] error code on failure. |
| */ |
| int |
| ble_hci_trans_hs_cmd_tx(uint8_t *cmd) |
| { |
| int rc; |
| |
| rc = ble_hci_emspi_cmdevt_tx(cmd, BLE_HCI_EMSPI_PKT_CMD); |
| return rc; |
| } |
| |
| /** |
| * Sends ACL data from host to controller. |
| * |
| * @param om The ACL data packet to send. |
| * |
| * @return 0 on success; |
| * A BLE_ERR_[...] error code on failure. |
| */ |
| int |
| ble_hci_trans_hs_acl_tx(struct os_mbuf *om) |
| { |
| int rc; |
| |
| rc = ble_hci_emspi_acl_tx(om); |
| return rc; |
| } |
| |
| /** |
| * Configures the HCI transport to call the specified callback upon receiving |
| * HCI packets from the controller. This function should only be called by by |
| * host. |
| * |
| * @param cmd_cb The callback to execute upon receiving an HCI |
| * event. |
| * @param cmd_arg Optional argument to pass to the command |
| * callback. |
| * @param acl_cb The callback to execute upon receiving ACL |
| * data. |
| * @param acl_arg Optional argument to pass to the ACL |
| * callback. |
| */ |
| void |
| ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *cmd_cb, |
| void *cmd_arg, |
| ble_hci_trans_rx_acl_fn *acl_cb, |
| void *acl_arg) |
| { |
| ble_hci_emspi_set_rx_cbs(cmd_cb, cmd_arg, acl_cb, acl_arg); |
| } |
| |
| /** |
| * Configures the HCI transport to operate with a host. The transport will |
| * execute specified callbacks upon receiving HCI packets from the controller. |
| * |
| * @param cmd_cb The callback to execute upon receiving an HCI |
| * event. |
| * @param cmd_arg Optional argument to pass to the command |
| * callback. |
| * @param acl_cb The callback to execute upon receiving ACL |
| * data. |
| * @param acl_arg Optional argument to pass to the ACL |
| * callback. |
| */ |
| void |
| ble_hci_trans_cfg_ll(ble_hci_trans_rx_cmd_fn *cmd_cb, |
| void *cmd_arg, |
| ble_hci_trans_rx_acl_fn *acl_cb, |
| void *acl_arg) |
| { |
| /* Unsupported. */ |
| assert(0); |
| } |
| |
| /** |
| * Allocates a flat buffer of the specified type. |
| * |
| * @param type The type of buffer to allocate; one of the |
| * BLE_HCI_TRANS_BUF_[...] constants. |
| * |
| * @return The allocated buffer on success; |
| * NULL on buffer exhaustion. |
| */ |
| uint8_t * |
| ble_hci_trans_buf_alloc(int type) |
| { |
| uint8_t *buf; |
| |
| switch (type) { |
| case BLE_HCI_TRANS_BUF_CMD: |
| buf = os_memblock_get(&ble_hci_emspi_cmd_pool); |
| break; |
| case BLE_HCI_TRANS_BUF_EVT_HI: |
| buf = os_memblock_get(&ble_hci_emspi_evt_hi_pool); |
| if (buf == NULL) { |
| /* If no high-priority event buffers remain, try to grab a |
| * low-priority one. |
| */ |
| buf = os_memblock_get(&ble_hci_emspi_evt_lo_pool); |
| } |
| break; |
| |
| case BLE_HCI_TRANS_BUF_EVT_LO: |
| buf = os_memblock_get(&ble_hci_emspi_evt_lo_pool); |
| break; |
| |
| default: |
| assert(0); |
| buf = NULL; |
| } |
| |
| return buf; |
| } |
| |
| /** |
| * Frees the specified flat buffer. The buffer must have been allocated via |
| * ble_hci_trans_buf_alloc(). |
| * |
| * @param buf The buffer to free. |
| */ |
| void |
| ble_hci_trans_buf_free(uint8_t *buf) |
| { |
| int rc; |
| |
| if (buf != NULL) { |
| if (os_memblock_from(&ble_hci_emspi_evt_hi_pool, buf)) { |
| rc = os_memblock_put(&ble_hci_emspi_evt_hi_pool, buf); |
| assert(rc == 0); |
| } else if (os_memblock_from(&ble_hci_emspi_evt_lo_pool, buf)) { |
| rc = os_memblock_put(&ble_hci_emspi_evt_lo_pool, buf); |
| assert(rc == 0); |
| } else { |
| assert(os_memblock_from(&ble_hci_emspi_cmd_pool, buf)); |
| rc = os_memblock_put(&ble_hci_emspi_cmd_pool, buf); |
| assert(rc == 0); |
| } |
| } |
| } |
| |
| /** |
| * Configures a callback to get executed whenever an ACL data packet is freed. |
| * The function is called in lieu of actually freeing the packet. |
| * |
| * @param cb The callback to configure. |
| * |
| * @return 0 on success. |
| */ |
| int |
| ble_hci_trans_set_acl_free_cb(os_mempool_put_fn *cb, void *arg) |
| { |
| ble_hci_emspi_acl_pool.mpe_put_cb = cb; |
| ble_hci_emspi_acl_pool.mpe_put_arg = arg; |
| return 0; |
| } |
| |
| /** |
| * Resets the HCI UART transport to a clean state. Frees all buffers and |
| * reconfigures the UART. |
| * |
| * @return 0 on success; |
| * A BLE_ERR_[...] error code on failure. |
| */ |
| int |
| ble_hci_trans_reset(void) |
| { |
| struct ble_hci_emspi_pkt *pkt; |
| |
| hal_gpio_write(MYNEWT_VAL(BLE_HCI_EMSPI_RESET_PIN), 1); |
| |
| while ((pkt = STAILQ_FIRST(&ble_hci_emspi_tx_q)) != NULL) { |
| STAILQ_REMOVE(&ble_hci_emspi_tx_q, pkt, ble_hci_emspi_pkt, next); |
| ble_hci_emspi_free_pkt(pkt->type, pkt->data, pkt->data); |
| os_memblock_put(&ble_hci_emspi_pkt_pool, pkt); |
| } |
| |
| return 0; |
| } |
| |
| static void |
| ble_hci_emspi_event_txrx(struct os_event *ev) |
| { |
| int rc; |
| |
| rc = ble_hci_emspi_rx_pkt(); |
| |
| do { |
| rc = ble_hci_emspi_tx_pkt(); |
| } while (rc == 0); |
| } |
| |
| static void |
| ble_hci_emspi_loop(void *unused) |
| { |
| while (1) { |
| os_eventq_run(&ble_hci_emspi_evq); |
| } |
| } |
| |
| static void |
| ble_hci_emspi_init_hw(void) |
| { |
| struct hal_spi_settings spi_cfg; |
| int rc; |
| |
| rc = hal_gpio_init_out(MYNEWT_VAL(BLE_HCI_EMSPI_RESET_PIN), 0); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = hal_gpio_init_out(MYNEWT_VAL(BLE_HCI_EMSPI_SS_PIN), 1); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| spi_cfg.data_order = HAL_SPI_MSB_FIRST; |
| spi_cfg.data_mode = HAL_SPI_MODE0; |
| spi_cfg.baudrate = MYNEWT_VAL(BLE_HCI_EMSPI_BAUD); |
| spi_cfg.word_size = HAL_SPI_WORD_SIZE_8BIT; |
| |
| rc = hal_spi_config(MYNEWT_VAL(BLE_HCI_EMSPI_SPI_NUM), &spi_cfg); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = hal_gpio_irq_init(MYNEWT_VAL(BLE_HCI_EMSPI_RDY_PIN), |
| ble_hci_emspi_rdy_isr, NULL, |
| HAL_GPIO_TRIG_RISING, HAL_GPIO_PULL_DOWN); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = hal_spi_enable(MYNEWT_VAL(BLE_HCI_EMSPI_SPI_NUM)); |
| assert(rc == 0); |
| |
| hal_gpio_write(MYNEWT_VAL(BLE_HCI_EMSPI_RESET_PIN), 1); |
| } |
| |
| /** |
| * Initializes the UART HCI transport module. |
| * |
| * @return 0 on success; |
| * A BLE_ERR_[...] error code on failure. |
| */ |
| void |
| ble_hci_emspi_init(void) |
| { |
| int rc; |
| |
| /* Ensure this function only gets called by sysinit. */ |
| SYSINIT_ASSERT_ACTIVE(); |
| |
| rc = os_mempool_ext_init(&ble_hci_emspi_acl_pool, |
| MYNEWT_VAL(BLE_ACL_BUF_COUNT), |
| ACL_BLOCK_SIZE, |
| ble_hci_emspi_acl_buf, |
| "ble_hci_emspi_acl_pool"); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = os_mbuf_pool_init(&ble_hci_emspi_acl_mbuf_pool, |
| &ble_hci_emspi_acl_pool.mpe_mp, |
| ACL_BLOCK_SIZE, |
| MYNEWT_VAL(BLE_ACL_BUF_COUNT)); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| /* |
| * Create memory pool of HCI command buffers. NOTE: we currently dont |
| * allow this to be configured. The controller will only allow one |
| * outstanding command. We decided to keep this a pool in case we allow |
| * allow the controller to handle more than one outstanding command. |
| */ |
| rc = os_mempool_init(&ble_hci_emspi_cmd_pool, |
| 1, |
| BLE_HCI_TRANS_CMD_SZ, |
| ble_hci_emspi_cmd_buf, |
| "ble_hci_emspi_cmd_pool"); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = os_mempool_init(&ble_hci_emspi_evt_hi_pool, |
| MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT), |
| MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE), |
| ble_hci_emspi_evt_hi_buf, |
| "ble_hci_emspi_evt_hi_pool"); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| rc = os_mempool_init(&ble_hci_emspi_evt_lo_pool, |
| MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT), |
| MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE), |
| ble_hci_emspi_evt_lo_buf, |
| "ble_hci_emspi_evt_lo_pool"); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| /* |
| * Create memory pool of packet list nodes. NOTE: the number of these |
| * buffers should be, at least, the total number of event buffers (hi |
| * and lo), the number of command buffers (currently 1) and the total |
| * number of buffers that the controller could possibly hand to the host. |
| */ |
| rc = os_mempool_init(&ble_hci_emspi_pkt_pool, |
| BLE_HCI_EMSPI_PKT_EVT_COUNT + 1 + |
| MYNEWT_VAL(BLE_HCI_ACL_OUT_COUNT), |
| sizeof (struct ble_hci_emspi_pkt), |
| ble_hci_emspi_pkt_buf, |
| "ble_hci_emspi_pkt_pool"); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| |
| STAILQ_INIT(&ble_hci_emspi_tx_q); |
| |
| ble_hci_emspi_init_hw(); |
| |
| /* Initialize the LL task */ |
| os_eventq_init(&ble_hci_emspi_evq); |
| rc = os_task_init(&ble_hci_emspi_task, "ble_hci_emspi", ble_hci_emspi_loop, |
| NULL, MYNEWT_VAL(BLE_HCI_EMSPI_PRIO), OS_WAIT_FOREVER, |
| ble_hci_emspi_stack, |
| MYNEWT_VAL(BLE_HCI_EMSPI_STACK_SIZE)); |
| SYSINIT_PANIC_ASSERT(rc == 0); |
| } |
