subsys/bluetooth/controller/coex/coex_ticker.c

/*
 * Copyright (c) 2022 Dronetag
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <errno.h>
#include <soc.h>

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/bluetooth/hci.h>

#include "controller/hal/ticker.h"
#include "controller/ticker/ticker.h"
#include "controller/include/ll.h"
#include "controller/ll_sw/nordic/hal/nrf5/debug.h"

LOG_MODULE_REGISTER(coex_ticker);

#define COEX_RADIO_WORK_DELAY_US  50
#define COEX_RADIO_WORK_RESCHEDULE_DELAY_US  200

struct coex_ticker_config {
	struct gpio_dt_spec grant_spec;
	size_t grant_delay_us;
};

struct coex_ticker_data {
	const struct device *dev;
	struct gpio_callback grant_irq_cb;
};

static int time_slot_delay(uint32_t ticks_at_expire, uint32_t ticks_delay,
				ticker_timeout_func callback, void *context)
{
	uint8_t instance_index;
	uint8_t ticker_id;
	int err;

	ll_coex_ticker_id_get(&instance_index, &ticker_id);

	/* start a secondary one-shot ticker after ticks_delay,
	 * this will let any radio role to gracefully abort and release the
	 * Radio h/w.
	 */
	err = ticker_start(instance_index, /* Radio instance ticker */
				1, /* user id for link layer ULL_HIGH */
				   /* (MAYFLY_CALL_ID_WORKER) */
				ticker_id, /* ticker_id */
				ticks_at_expire, /* current tick */
				ticks_delay, /* one-shot delayed timeout */
				0, /* periodic timeout  */
				0, /* periodic remainder */
				0, /* lazy, voluntary skips */
				0,
				callback, /* handler for executing radio abort or */
					 /* coex work */
				context, /* the context for the coex operation */
				NULL, /* no op callback */
				NULL);

	return err;
}


static void time_slot_callback_work(uint32_t ticks_at_expire,
					uint32_t ticks_drift,
					uint32_t remainder,
					uint16_t lazy, uint8_t force,
					void *context)
{
	int ret;
	uint8_t instance_index;
	uint8_t ticker_id;
	const struct device *dev = context;
	const struct coex_ticker_config *config = dev->config;

	__ASSERT(ll_radio_state_is_idle(),
		 "Radio is on during coex operation.\n");

	/* Read grant pin */
	if (gpio_pin_get_dt(&config->grant_spec) == 0) {
		DEBUG_COEX_GRANT(1);

		if (!ll_radio_state_is_idle()) {
			ll_radio_state_abort();
		}
		/* Schedule another check for grant pin and abort any events scheduled */
		time_slot_delay(ticker_ticks_now_get(),
				HAL_TICKER_US_TO_TICKS(COEX_RADIO_WORK_RESCHEDULE_DELAY_US),
				time_slot_callback_work,
				context);
	} else {
		LOG_DBG("COEX Inhibit Off");
		DEBUG_COEX_IRQ(0);
		DEBUG_COEX_GRANT(0);

		/* Enable coex pin interrupt */
		gpio_pin_interrupt_configure_dt(&config->grant_spec, GPIO_INT_EDGE_TO_INACTIVE);

		/* Stop the time slot ticker */
		ll_coex_ticker_id_get(&instance_index, &ticker_id);

		ret = ticker_stop(instance_index, 0, ticker_id, NULL, NULL);
		if (ret != TICKER_STATUS_SUCCESS &&
			ret != TICKER_STATUS_BUSY) {
			__ASSERT(0, "Failed to stop ticker.\n");
		}
	}
}

static void time_slot_callback_abort(uint32_t ticks_at_expire,
					 uint32_t ticks_drift,
					 uint32_t remainder,
					 uint16_t lazy, uint8_t force,
					 void *context)
{
	ll_radio_state_abort();
	time_slot_delay(ticks_at_expire,
			HAL_TICKER_US_TO_TICKS(COEX_RADIO_WORK_DELAY_US),
			time_slot_callback_work,
			context);
}

static int coex_ticker_grant_start(const struct device *dev)
{
	const struct coex_ticker_config *cfg = dev->config;
	uint32_t err;

	err = time_slot_delay(
		ticker_ticks_now_get(),
		HAL_TICKER_US_TO_TICKS(cfg->grant_delay_us - COEX_RADIO_WORK_DELAY_US),
		time_slot_callback_abort,
		(void *)dev
	);

	if (err != TICKER_STATUS_SUCCESS && err != TICKER_STATUS_BUSY) {
		return -EBUSY;
	}

	return 0;
}


static void coex_ticker_grant_irq_handler(const struct device *dev,
					struct gpio_callback *cb, uint32_t pins)
{
	ARG_UNUSED(dev);
	ARG_UNUSED(pins);
	struct coex_ticker_data *data = CONTAINER_OF(cb, struct coex_ticker_data, grant_irq_cb);
	const struct coex_ticker_config *config = data->dev->config;

	LOG_DBG("COEX Inhibit IRQ Detected");
	DEBUG_COEX_IRQ(1);
	DEBUG_COEX_GRANT(0);

	gpio_pin_interrupt_configure_dt(&config->grant_spec, GPIO_INT_DISABLE);
	coex_ticker_grant_start(data->dev);
}


static int coex_ticker_init(const struct device *dev)
{
	const struct coex_ticker_config *config = dev->config;
	struct coex_ticker_data *data = dev->data;
	int res;

	data->dev = dev;

	DEBUG_COEX_INIT();
	res = gpio_pin_configure_dt(&config->grant_spec, GPIO_INPUT);
	if (res) {
		return res;
	}

	gpio_init_callback(&data->grant_irq_cb,
					   coex_ticker_grant_irq_handler,
					   BIT(config->grant_spec.pin));

	res = gpio_add_callback(config->grant_spec.port, &data->grant_irq_cb);
	if (res) {
		return res;
	}

	res = gpio_pin_interrupt_configure_dt(&config->grant_spec, GPIO_INT_EDGE_TO_INACTIVE);
	if (res) {
		return res;
	}

	return 0;
}

#define RADIO_NODE DT_NODELABEL(radio)
#define COEX_NODE DT_PROP(RADIO_NODE, coex)

#if DT_NODE_EXISTS(COEX_NODE)
static struct coex_ticker_config config = {
	.grant_spec = GPIO_DT_SPEC_GET(COEX_NODE, grant_gpios),
	.grant_delay_us = DT_PROP(COEX_NODE, grant_delay_us)
};
static struct coex_ticker_data data;

DEVICE_DEFINE(coex_ticker, "COEX_TICKER", &coex_ticker_init, NULL,
	&data, &config,
	APPLICATION, 90,
	NULL);
#endif