380 lines
9.1 KiB
C
380 lines
9.1 KiB
C
/*
|
|
* Copyright (c) 2017 Nordic Semiconductor ASA
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#define DT_DRV_COMPAT nordic_nrf_sw_pwm
|
|
|
|
#include <soc.h>
|
|
#include <hal/nrf_gpio.h>
|
|
|
|
#include <drivers/pwm.h>
|
|
#include <nrf_peripherals.h>
|
|
|
|
#define LOG_LEVEL CONFIG_PWM_LOG_LEVEL
|
|
#include <logging/log.h>
|
|
LOG_MODULE_REGISTER(pwm_nrf5_sw);
|
|
|
|
#define GENERATOR_NODE DT_PHANDLE(DT_DRV_INST(0), generator)
|
|
#define GENERATOR_CC_NUM DT_PROP(GENERATOR_NODE, cc_num)
|
|
|
|
#if DT_NODE_HAS_COMPAT(GENERATOR_NODE, nordic_nrf_rtc)
|
|
#define USE_RTC 1
|
|
#define GENERATOR_ADDR ((NRF_RTC_Type *) DT_REG_ADDR(GENERATOR_NODE))
|
|
BUILD_ASSERT(DT_INST_PROP(0, clock_prescaler) == 0,
|
|
"Only clock-prescaler = <0> is supported when used with RTC");
|
|
#else
|
|
#define USE_RTC 0
|
|
#define GENERATOR_ADDR ((NRF_TIMER_Type *) DT_REG_ADDR(GENERATOR_NODE))
|
|
#endif
|
|
|
|
/* One compare channel is needed to set the PWM period, hence +1. */
|
|
#if ((DT_INST_PROP(0, channel_count) + 1) > GENERATOR_CC_NUM)
|
|
#error "Invalid number of PWM channels configured."
|
|
#endif
|
|
#define PWM_0_MAP_SIZE DT_INST_PROP(0, channel_count)
|
|
|
|
struct pwm_config {
|
|
union {
|
|
NRF_RTC_Type *rtc;
|
|
NRF_TIMER_Type *timer;
|
|
};
|
|
uint8_t gpiote_base;
|
|
uint8_t ppi_base;
|
|
uint8_t map_size;
|
|
uint8_t prescaler;
|
|
};
|
|
|
|
struct chan_map {
|
|
uint32_t pwm;
|
|
uint32_t pulse_cycles;
|
|
};
|
|
|
|
struct pwm_data {
|
|
uint32_t period_cycles;
|
|
struct chan_map map[PWM_0_MAP_SIZE];
|
|
};
|
|
|
|
static inline NRF_RTC_Type *pwm_config_rtc(const struct pwm_config *config)
|
|
{
|
|
#if USE_RTC
|
|
return config->rtc;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
static inline NRF_TIMER_Type *pwm_config_timer(const struct pwm_config *config)
|
|
{
|
|
#if !USE_RTC
|
|
return config->timer;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
static uint32_t pwm_period_check(struct pwm_data *data, uint8_t map_size,
|
|
uint32_t pwm, uint32_t period_cycles,
|
|
uint32_t pulse_cycles)
|
|
{
|
|
uint8_t i;
|
|
|
|
/* allow 0% and 100% duty cycle, as it does not use PWM. */
|
|
if ((pulse_cycles == 0U) || (pulse_cycles == period_cycles)) {
|
|
return 0;
|
|
}
|
|
|
|
/* fail if requested period does not match already running period */
|
|
for (i = 0U; i < map_size; i++) {
|
|
if ((data->map[i].pwm != pwm) &&
|
|
(data->map[i].pulse_cycles != 0U) &&
|
|
(period_cycles != data->period_cycles)) {
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static uint8_t pwm_channel_map(struct pwm_data *data, uint8_t map_size,
|
|
uint32_t pwm)
|
|
{
|
|
uint8_t i;
|
|
|
|
/* find pin, if already present */
|
|
for (i = 0U; i < map_size; i++) {
|
|
if (pwm == data->map[i].pwm) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/* find a free entry */
|
|
i = map_size;
|
|
while (i--) {
|
|
if (data->map[i].pulse_cycles == 0U) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
static int pwm_nrf5_sw_pin_set(const struct device *dev, uint32_t pwm,
|
|
uint32_t period_cycles, uint32_t pulse_cycles,
|
|
pwm_flags_t flags)
|
|
{
|
|
const struct pwm_config *config = dev->config;
|
|
NRF_TIMER_Type *timer = pwm_config_timer(config);
|
|
NRF_RTC_Type *rtc = pwm_config_rtc(config);
|
|
struct pwm_data *data = dev->data;
|
|
uint8_t ppi_index;
|
|
uint32_t ppi_mask;
|
|
uint8_t channel;
|
|
uint32_t ret;
|
|
|
|
if (flags) {
|
|
/* PWM polarity not supported (yet?) */
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
/* check if requested period is allowed while other channels are
|
|
* active.
|
|
*/
|
|
ret = pwm_period_check(data, config->map_size, pwm, period_cycles,
|
|
pulse_cycles);
|
|
if (ret) {
|
|
LOG_ERR("Incompatible period");
|
|
return ret;
|
|
}
|
|
|
|
if (USE_RTC) {
|
|
/* pulse_cycles - 1 is written to 24-bit CC */
|
|
if (period_cycles > BIT_MASK(24) + 1) {
|
|
LOG_ERR("Too long period (%u)!", period_cycles);
|
|
return -EINVAL;
|
|
}
|
|
} else {
|
|
/* TODO: if the assigned NRF_TIMER supports higher bit
|
|
* resolution, use that info in config struct.
|
|
*/
|
|
if (period_cycles > UINT16_MAX) {
|
|
LOG_ERR("Too long period (%u), adjust pwm prescaler!",
|
|
period_cycles);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/* map pwm pin to GPIOTE config/channel */
|
|
channel = pwm_channel_map(data, config->map_size, pwm);
|
|
if (channel >= config->map_size) {
|
|
LOG_ERR("No more channels available");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
LOG_DBG("PWM %d, period %u, pulse %u", pwm,
|
|
period_cycles, pulse_cycles);
|
|
|
|
/* clear GPIOTE config */
|
|
NRF_GPIOTE->CONFIG[config->gpiote_base + channel] = 0;
|
|
|
|
/* clear PPI used */
|
|
if (USE_RTC) {
|
|
ppi_index = config->ppi_base + (channel * 3);
|
|
ppi_mask = BIT(ppi_index) | BIT(ppi_index + 1) |
|
|
BIT(ppi_index + 2);
|
|
} else {
|
|
ppi_index = config->ppi_base + (channel * 2);
|
|
ppi_mask = BIT(ppi_index) | BIT(ppi_index + 1);
|
|
}
|
|
NRF_PPI->CHENCLR = ppi_mask;
|
|
|
|
/* configure GPIO pin as output */
|
|
nrf_gpio_cfg_output(pwm);
|
|
if (pulse_cycles == 0U) {
|
|
/* 0% duty cycle, keep pin low */
|
|
nrf_gpio_pin_clear(pwm);
|
|
|
|
goto pin_set_pwm_off;
|
|
} else if (pulse_cycles == period_cycles) {
|
|
/* 100% duty cycle, keep pin high */
|
|
nrf_gpio_pin_set(pwm);
|
|
|
|
goto pin_set_pwm_off;
|
|
} else {
|
|
/* x% duty cycle, start PWM with pin low */
|
|
nrf_gpio_pin_clear(pwm);
|
|
}
|
|
|
|
/* configure RTC / TIMER */
|
|
if (USE_RTC) {
|
|
rtc->EVENTS_COMPARE[channel] = 0;
|
|
rtc->EVENTS_COMPARE[config->map_size] = 0;
|
|
|
|
/*
|
|
* '- 1' adjusts pulse and period cycles to the fact that CLEAR
|
|
* task event is generated always one LFCLK cycle after period
|
|
* COMPARE value is reached.
|
|
*/
|
|
rtc->CC[channel] = pulse_cycles - 1;
|
|
rtc->CC[config->map_size] = period_cycles - 1;
|
|
rtc->TASKS_CLEAR = 1;
|
|
} else {
|
|
timer->EVENTS_COMPARE[channel] = 0;
|
|
timer->EVENTS_COMPARE[config->map_size] = 0;
|
|
|
|
timer->CC[channel] = pulse_cycles;
|
|
timer->CC[config->map_size] = period_cycles;
|
|
timer->TASKS_CLEAR = 1;
|
|
}
|
|
|
|
/* configure GPIOTE, toggle with initialise output high */
|
|
NRF_GPIOTE->CONFIG[config->gpiote_base + channel] = 0x00130003 |
|
|
(pwm << 8);
|
|
|
|
/* setup PPI */
|
|
if (USE_RTC) {
|
|
NRF_PPI->CH[ppi_index].EEP =
|
|
(uint32_t) &(rtc->EVENTS_COMPARE[channel]);
|
|
NRF_PPI->CH[ppi_index].TEP =
|
|
(uint32_t) &(NRF_GPIOTE->TASKS_OUT[channel]);
|
|
NRF_PPI->CH[ppi_index + 1].EEP =
|
|
(uint32_t) &(rtc->EVENTS_COMPARE[config->map_size]);
|
|
NRF_PPI->CH[ppi_index + 1].TEP =
|
|
(uint32_t) &(NRF_GPIOTE->TASKS_OUT[channel]);
|
|
NRF_PPI->CH[ppi_index + 2].EEP =
|
|
(uint32_t) &(rtc->EVENTS_COMPARE[config->map_size]);
|
|
NRF_PPI->CH[ppi_index + 2].TEP =
|
|
(uint32_t) &(rtc->TASKS_CLEAR);
|
|
} else {
|
|
NRF_PPI->CH[ppi_index].EEP =
|
|
(uint32_t) &(timer->EVENTS_COMPARE[channel]);
|
|
NRF_PPI->CH[ppi_index].TEP =
|
|
(uint32_t) &(NRF_GPIOTE->TASKS_OUT[channel]);
|
|
NRF_PPI->CH[ppi_index + 1].EEP =
|
|
(uint32_t) &(timer->EVENTS_COMPARE[config->map_size]);
|
|
NRF_PPI->CH[ppi_index + 1].TEP =
|
|
(uint32_t) &(NRF_GPIOTE->TASKS_OUT[channel]);
|
|
}
|
|
NRF_PPI->CHENSET = ppi_mask;
|
|
|
|
/* start timer, hence PWM */
|
|
if (USE_RTC) {
|
|
rtc->TASKS_START = 1;
|
|
} else {
|
|
timer->TASKS_START = 1;
|
|
}
|
|
|
|
/* store the pwm/pin and its param */
|
|
data->period_cycles = period_cycles;
|
|
data->map[channel].pwm = pwm;
|
|
data->map[channel].pulse_cycles = pulse_cycles;
|
|
|
|
return 0;
|
|
|
|
pin_set_pwm_off:
|
|
data->map[channel].pulse_cycles = 0U;
|
|
bool pwm_active = false;
|
|
|
|
/* stop timer if all channels are inactive */
|
|
for (channel = 0U; channel < config->map_size; channel++) {
|
|
if (data->map[channel].pulse_cycles) {
|
|
pwm_active = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!pwm_active) {
|
|
/* No active PWM, stop timer */
|
|
if (USE_RTC) {
|
|
rtc->TASKS_STOP = 1;
|
|
} else {
|
|
timer->TASKS_STOP = 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int pwm_nrf5_sw_get_cycles_per_sec(const struct device *dev,
|
|
uint32_t pwm,
|
|
uint64_t *cycles)
|
|
{
|
|
const struct pwm_config *config = dev->config;
|
|
|
|
if (USE_RTC) {
|
|
/*
|
|
* RTC frequency is derived from 32768Hz source without any
|
|
* prescaler
|
|
*/
|
|
*cycles = 32768UL;
|
|
} else {
|
|
/*
|
|
* HF timer frequency is derived from 16MHz source with a
|
|
* prescaler
|
|
*/
|
|
*cycles = 16000000UL / BIT(config->prescaler);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct pwm_driver_api pwm_nrf5_sw_drv_api_funcs = {
|
|
.pin_set = pwm_nrf5_sw_pin_set,
|
|
.get_cycles_per_sec = pwm_nrf5_sw_get_cycles_per_sec,
|
|
};
|
|
|
|
static int pwm_nrf5_sw_init(const struct device *dev)
|
|
{
|
|
const struct pwm_config *config = dev->config;
|
|
NRF_TIMER_Type *timer = pwm_config_timer(config);
|
|
NRF_RTC_Type *rtc = pwm_config_rtc(config);
|
|
|
|
if (USE_RTC) {
|
|
/* setup RTC */
|
|
rtc->PRESCALER = 0;
|
|
|
|
/*
|
|
* TODO: set EVTEN to map_size if not 3, i.e. if RTC supports
|
|
* less than 4 compares, then less channels can be supported.
|
|
*/
|
|
rtc->EVTENSET = (RTC_EVTENSET_COMPARE0_Msk |
|
|
RTC_EVTENSET_COMPARE1_Msk |
|
|
RTC_EVTENSET_COMPARE2_Msk |
|
|
RTC_EVTENSET_COMPARE3_Msk);
|
|
} else {
|
|
/* setup HF timer */
|
|
timer->MODE = TIMER_MODE_MODE_Timer;
|
|
timer->PRESCALER = config->prescaler;
|
|
timer->BITMODE = TIMER_BITMODE_BITMODE_16Bit;
|
|
|
|
/*
|
|
* TODO: set shorts according to map_size if not 3, i.e. if
|
|
* NRF_TIMER supports more than 4 compares, then more channels
|
|
* can be supported.
|
|
*/
|
|
timer->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct pwm_config pwm_nrf5_sw_0_config = {
|
|
COND_CODE_1(USE_RTC, (.rtc), (.timer)) = GENERATOR_ADDR,
|
|
.ppi_base = DT_INST_PROP(0, ppi_base),
|
|
.gpiote_base = DT_INST_PROP(0, gpiote_base),
|
|
.map_size = PWM_0_MAP_SIZE,
|
|
.prescaler = DT_INST_PROP(0, clock_prescaler),
|
|
};
|
|
|
|
static struct pwm_data pwm_nrf5_sw_0_data;
|
|
|
|
DEVICE_DT_INST_DEFINE(0,
|
|
pwm_nrf5_sw_init,
|
|
NULL,
|
|
&pwm_nrf5_sw_0_data,
|
|
&pwm_nrf5_sw_0_config,
|
|
POST_KERNEL,
|
|
CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&pwm_nrf5_sw_drv_api_funcs);
|