static int h4_send(struct net_buf *buf)
{
BT_DBG("buf %p type %u len %u", buf, bt_buf_get_type(buf), buf->len);
net_buf_put(&tx.fifo, buf);
uart_irq_tx_enable(h4_dev);
return 0;
}
static int h4_send(struct net_buf *buf)
{
BT_DBG("buf %p type %u len %u", buf, bt_buf_get_type(buf), buf->len);
switch (bt_buf_get_type(buf)) {
case BT_BUF_ACL_OUT:
uart_poll_out(h4_dev, H4_ACL);
break;
case BT_BUF_CMD:
uart_poll_out(h4_dev, H4_CMD);
break;
default:
return -EINVAL;
}
while (buf->len) {
uart_poll_out(h4_dev, net_buf_pull_u8(buf));
}
net_buf_unref(buf);
return 0;
}
static inline void process_tx(void)
{
int bytes;
if (!tx.buf) {
tx.buf = net_buf_get(&tx.fifo, K_NO_WAIT);
if (!tx.buf) {
BT_ERR("TX interrupt but no pending buffer!");
uart_irq_tx_disable(h4_dev);
return;
}
}
if (!tx.type) {
switch (bt_buf_get_type(tx.buf)) {
case BT_BUF_ACL_OUT:
tx.type = H4_ACL;
break;
case BT_BUF_CMD:
tx.type = H4_CMD;
break;
default:
BT_ERR("Unknown buffer type");
goto done;
}
bytes = uart_fifo_fill(h4_dev, &tx.type, 1);
if (bytes != 1) {
BT_WARN("Unable to send H:4 type");
tx.type = H4_NONE;
return;
}
}
bytes = uart_fifo_fill(h4_dev, tx.buf->data, tx.buf->len);
net_buf_pull(tx.buf, bytes);
if (tx.buf->len) {
return;
}
done:
tx.type = H4_NONE;
net_buf_unref(tx.buf);
tx.buf = net_buf_get(&tx.fifo, K_NO_WAIT);
if (!tx.buf) {
uart_irq_tx_disable(h4_dev);
}
}
static int h5_queue(struct net_buf *buf)
{
uint8_t type;
BT_DBG("buf %p type %u len %u", buf, bt_buf_get_type(buf), buf->len);
switch (bt_buf_get_type(buf)) {
case BT_BUF_CMD:
type = HCI_COMMAND_PKT;
break;
case BT_BUF_ACL_OUT:
type = HCI_ACLDATA_PKT;
break;
default:
BT_ERR("Unknown packet type %u", bt_buf_get_type(buf));
return -1;
}
memcpy(net_buf_push(buf, sizeof(type)), &type, sizeof(type));
nano_fifo_put(&h5.tx_queue, buf);
return 0;
}
static int bt_spi_send(struct net_buf *buf)
{
u8_t header[5] = { SPI_WRITE, 0x00, 0x00, 0x00, 0x00 };
u32_t pending;
/* Buffer needs an additional byte for type */
if (buf->len >= SPI_MAX_MSG_LEN) {
BT_ERR("Message too long");
return -EINVAL;
}
/* Allow time for the read thread to handle interrupt */
while (true) {
gpio_pin_read(irq_dev, GPIO_IRQ_PIN, &pending);
if (!pending) {
break;
}
k_sleep(1);
}
k_sem_take(&sem_busy, K_FOREVER);
switch (bt_buf_get_type(buf)) {
case BT_BUF_ACL_OUT:
net_buf_push_u8(buf, HCI_ACL);
break;
case BT_BUF_CMD:
net_buf_push_u8(buf, HCI_CMD);
break;
default:
BT_ERR("Unsupported type");
k_sem_give(&sem_busy);
return -EINVAL;
}
/* Poll sanity values until device has woken-up */
do {
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
gpio_pin_write(cs_dev, GPIO_CS_PIN, 1);
gpio_pin_write(cs_dev, GPIO_CS_PIN, 0);
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
spi_transceive(spi_dev, header, 5, rxmsg, 5);
/*
* RX Header (rxmsg) must contain a sanity check Byte and size
* information. If it does not contain BOTH then it is
* sleeping or still in the initialisation stage (waking-up).
*/
} while (rxmsg[STATUS_HEADER_READY] != READY_NOW ||
(rxmsg[1] | rxmsg[2] | rxmsg[3] | rxmsg[4]) == 0);
/* Transmit the message */
do {
spi_transceive(spi_dev, buf->data, buf->len, rxmsg, buf->len);
} while (rxmsg[0] == 0);
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
/* Deselect chip */
gpio_pin_write(cs_dev, GPIO_CS_PIN, 1);
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
k_sem_give(&sem_busy);
spi_dump_message("TX:ed", buf->data, buf->len);
#if defined(CONFIG_BLUETOOTH_SPI_BLUENRG)
/*
* Since a RESET has been requested, the chip will now restart.
* Unfortunately the BlueNRG will reply with "reset received" but
* since it does not send back a NOP, we have no way to tell when the
* RESET has actually taken palce. Instead, we use the vendor command
* EVT_BLUE_INITIALIZED as an indication that it is safe to proceed.
*/
if (bt_spi_get_cmd(buf->data) == BT_HCI_OP_RESET) {
k_sem_take(&sem_initialised, K_FOREVER);
}
#endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */
net_buf_unref(buf);
return 0;
}
