blob: 5252c2c56cb3aa6db8bf35471094bb28ff440894 [file] [log] [blame]
/*
* Copyright (c) 2022 Andes Technology
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/drivers/counter.h>
#include <zephyr/spinlock.h>
#include <zephyr/irq.h>
#include <zephyr/arch/cpu.h>
#include <string.h>
#define DT_DRV_COMPAT andestech_atcpit100
/* register definitions */
#define REG_IDR 0x00 /* ID and Revision Reg. */
#define REG_CFG 0x10 /* Configuration Reg. */
#define REG_INTE 0x14 /* Interrupt Enable Reg. */
#define REG_ISTA 0x18 /* Interrupt Status Reg. */
#define REG_CHEN 0x1C /* Channel Enable Reg. */
#define REG_CTRL0 0x20 /* Channel 0 Control Reg. */
#define REG_RELD0 0x24 /* Channel 0 Reload Reg. */
#define REG_CNTR0 0x28 /* Channel 0 Counter Reg. */
#define REG_CTRL1 0x30 /* Channel 1 Control Reg. */
#define REG_RELD1 0x34 /* Channel 1 Reload Reg. */
#define REG_CNTR1 0x38 /* Channel 1 Counter Reg. */
#define REG_CTRL2 0x40 /* Channel 2 Control Reg. */
#define REG_RELD2 0x44 /* Channel 2 Reload Reg. */
#define REG_CNTR2 0x48 /* Channel 2 Counter Reg. */
#define REG_CTRL3 0x50 /* Channel 3 Control Reg. */
#define REG_RELD3 0x54 /* Channel 3 Reload Reg. */
#define REG_CNTR3 0x58 /* Channel 3 Counter Reg. */
#define PIT_BASE (((const struct atcpit100_config *)(dev)->config)->base)
#define PIT_INTE(dev) (PIT_BASE + REG_INTE)
#define PIT_ISTA(dev) (PIT_BASE + REG_ISTA)
#define PIT_CHEN(dev) (PIT_BASE + REG_CHEN)
#define PIT_CH_CTRL(dev, ch) (PIT_BASE + REG_CTRL0 + (ch << 4))
#define PIT_CH_RELD(dev, ch) (PIT_BASE + REG_RELD0 + (ch << 4))
#define PIT_CH_CNTR(dev, ch) (PIT_BASE + REG_CNTR0 + (ch << 4))
#define CTRL_CH_SRC_PCLK BIT(3)
#define CTRL_CH_MODE_32BIT BIT(0)
#define CHANNEL_NUM (4)
#define CH_NUM_PER_COUNTER (CHANNEL_NUM - 1)
#define TIMER0_CHANNEL(ch) BIT(((ch) * CHANNEL_NUM))
typedef void (*atcpit100_cfg_func_t)(void);
struct atcpit100_config {
struct counter_config_info info;
uint32_t base;
uint32_t divider;
uint32_t irq_num;
atcpit100_cfg_func_t cfg_func;
};
struct counter_atcpit100_ch_data {
counter_alarm_callback_t alarm_callback;
void *alarm_user_data;
};
struct atcpit100_data {
counter_top_callback_t top_callback;
void *top_user_data;
uint32_t guard_period;
struct k_spinlock lock;
struct counter_atcpit100_ch_data ch_data[CH_NUM_PER_COUNTER];
};
static inline uint32_t get_current_tick(const struct device *dev, uint32_t ch)
{
const struct atcpit100_config *config = dev->config;
uint32_t top, now_cnt;
/* Preload cycles is reload register + 1 */
top = sys_read32(PIT_CH_RELD(dev, ch)) + 1;
now_cnt = top - sys_read32(PIT_CH_CNTR(dev, ch));
return (now_cnt / config->divider);
}
static void atcpit100_irq_handler(void *arg)
{
struct device *dev = (struct device *)arg;
struct atcpit100_data *data = dev->data;
counter_alarm_callback_t cb;
uint32_t int_status, int_enable, ch_enable, cur_ticks;
uint8_t i;
ch_enable = sys_read32(PIT_CHEN(dev));
int_enable = sys_read32(PIT_INTE(dev));
int_status = sys_read32(PIT_ISTA(dev));
if (int_status & TIMER0_CHANNEL(3)) {
if (data->top_callback) {
data->top_callback(dev, data->top_user_data);
}
}
for (i = 0; i < CH_NUM_PER_COUNTER; i++) {
if (int_status & TIMER0_CHANNEL(i)) {
int_enable &= ~TIMER0_CHANNEL(i);
ch_enable &= ~TIMER0_CHANNEL(i);
cb = data->ch_data[i].alarm_callback;
data->ch_data[i].alarm_callback = NULL;
cur_ticks = get_current_tick(dev, 3);
cb(dev, i, cur_ticks, data->ch_data[i].alarm_user_data);
}
}
/* Disable channel and interrupt */
sys_write32(int_enable, PIT_INTE(dev));
sys_write32(ch_enable, PIT_CHEN(dev));
/* Clear interrupt status */
sys_write32(int_status, PIT_ISTA(dev));
}
static int counter_atcpit100_init(const struct device *dev)
{
const struct atcpit100_config *config = dev->config;
uint32_t reg;
/* Disable all channels */
sys_write32(0, PIT_CHEN(dev));
/* Channel 0 ~ 3, 32 bits timer, PCLK source */
reg = CTRL_CH_MODE_32BIT | CTRL_CH_SRC_PCLK;
sys_write32(reg, PIT_CH_CTRL(dev, 0));
sys_write32(reg, PIT_CH_CTRL(dev, 1));
sys_write32(reg, PIT_CH_CTRL(dev, 2));
sys_write32(reg, PIT_CH_CTRL(dev, 3));
/* Disable all interrupt and clear all pending interrupt */
sys_write32(0, PIT_INTE(dev));
sys_write32(UINT32_MAX, PIT_ISTA(dev));
/* Select channel 3 as default counter and set max top value */
reg = config->info.max_top_value * config->divider;
/* Set cycle - 1 to reload register */
sys_write32((reg - 1), PIT_CH_RELD(dev, 3));
config->cfg_func();
irq_enable(config->irq_num);
return 0;
}
static int atcpit100_start(const struct device *dev)
{
struct atcpit100_data *data = dev->data;
k_spinlock_key_t key;
uint32_t reg;
key = k_spin_lock(&data->lock);
/* Enable channel */
reg = sys_read32(PIT_CHEN(dev));
reg |= TIMER0_CHANNEL(3);
sys_write32(reg, PIT_CHEN(dev));
k_spin_unlock(&data->lock, key);
return 0;
}
static int atcpit100_stop(const struct device *dev)
{
struct atcpit100_data *data = dev->data;
k_spinlock_key_t key;
uint32_t reg;
key = k_spin_lock(&data->lock);
/* Disable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg &= ~TIMER0_CHANNEL(3);
sys_write32(reg, PIT_INTE(dev));
/* Disable channel */
reg = sys_read32(PIT_CHEN(dev));
reg &= ~TIMER0_CHANNEL(3);
sys_write32(reg, PIT_CHEN(dev));
/* Clear interrupt status */
sys_write32(TIMER0_CHANNEL(3), PIT_ISTA(dev));
k_spin_unlock(&data->lock, key);
return 0;
}
static int atcpit100_get_value(const struct device *dev, uint32_t *ticks)
{
struct atcpit100_data *data = dev->data;
k_spinlock_key_t key;
key = k_spin_lock(&data->lock);
*ticks = get_current_tick(dev, 3);
k_spin_unlock(&data->lock, key);
return 0;
}
static int atcpit100_set_alarm(const struct device *dev, uint8_t chan_id,
const struct counter_alarm_cfg *alarm_cfg)
{
const struct atcpit100_config *config = dev->config;
struct atcpit100_data *data = dev->data;
uint32_t top, now_cnt, remain_cnt, alarm_cnt, flags, reg;
k_spinlock_key_t key;
int err = 0;
if (chan_id >= CH_NUM_PER_COUNTER) {
return -ENOTSUP;
}
if (!alarm_cfg->callback) {
return -EINVAL;
}
if (data->ch_data[chan_id].alarm_callback) {
return -EBUSY;
}
key = k_spin_lock(&data->lock);
/* Preload cycles is reload register + 1 */
top = sys_read32(PIT_CH_RELD(dev, 3)) + 1;
remain_cnt = sys_read32(PIT_CH_CNTR(dev, 3));
alarm_cnt = alarm_cfg->ticks * config->divider;
if (alarm_cnt > top) {
err = -EINVAL;
goto out;
}
flags = alarm_cfg->flags;
data->ch_data[chan_id].alarm_callback = alarm_cfg->callback;
data->ch_data[chan_id].alarm_user_data = alarm_cfg->user_data;
if (flags & COUNTER_ALARM_CFG_ABSOLUTE) {
uint32_t irq_on_late, max_rel_val;
now_cnt = top - remain_cnt;
max_rel_val = top - (data->guard_period * config->divider);
irq_on_late = flags & COUNTER_ALARM_CFG_EXPIRE_WHEN_LATE;
if (now_cnt < alarm_cnt) {
/* Absolute alarm is in this round counting */
reg = alarm_cnt - now_cnt;
irq_on_late = 0;
} else {
/* Absolute alarm is in the next round counting */
reg = alarm_cnt + remain_cnt;
}
if (reg > max_rel_val) {
/* Absolute alarm is in the guard period */
err = -ETIME;
if (!irq_on_late) {
data->ch_data[chan_id].alarm_callback = NULL;
goto out;
}
}
if (irq_on_late) {
/* Trigger interrupt immediately */
reg = 1;
}
} else {
/* Round up decreasing counter to tick boundary */
now_cnt = remain_cnt + config->divider - 1;
now_cnt = (now_cnt / config->divider) * config->divider;
/* Adjusting relative alarm counter to tick boundary */
reg = alarm_cnt - (now_cnt - remain_cnt);
}
/* Set cycle - 1 to reload register */
sys_write32((reg - 1), PIT_CH_RELD(dev, chan_id));
/* Enable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg |= TIMER0_CHANNEL(chan_id);
sys_write32(reg, PIT_INTE(dev));
/* Enable channel */
reg = sys_read32(PIT_CHEN(dev));
reg |= TIMER0_CHANNEL(chan_id);
sys_write32(reg, PIT_CHEN(dev));
out:
k_spin_unlock(&data->lock, key);
return err;
}
static int atcpit100_cancel_alarm(const struct device *dev, uint8_t chan_id)
{
struct atcpit100_data *data = dev->data;
k_spinlock_key_t key;
uint32_t reg;
if (chan_id >= CH_NUM_PER_COUNTER) {
return -ENOTSUP;
}
key = k_spin_lock(&data->lock);
/* Disable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg &= ~TIMER0_CHANNEL(chan_id);
sys_write32(reg, PIT_INTE(dev));
/* Disable channel */
reg = sys_read32(PIT_CHEN(dev));
reg &= ~TIMER0_CHANNEL(chan_id);
sys_write32(reg, PIT_CHEN(dev));
/* Clear interrupt status */
sys_write32(TIMER0_CHANNEL(chan_id), PIT_ISTA(dev));
data->ch_data[chan_id].alarm_callback = NULL;
k_spin_unlock(&data->lock, key);
return 0;
}
static int atcpit100_set_top_value(const struct device *dev,
const struct counter_top_cfg *cfg)
{
const struct atcpit100_config *config = dev->config;
struct atcpit100_data *data = dev->data;
uint32_t ticks, reg, reset_counter = 1;
k_spinlock_key_t key;
int err = 0;
uint8_t i;
for (i = 0; i < counter_get_num_of_channels(dev); i++) {
if (data->ch_data[i].alarm_callback) {
return -EBUSY;
}
}
if (cfg->ticks > config->info.max_top_value) {
return -ENOTSUP;
}
key = k_spin_lock(&data->lock);
if (cfg->callback) {
/* Disable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg &= ~TIMER0_CHANNEL(3);
sys_write32(reg, PIT_INTE(dev));
data->top_callback = cfg->callback;
data->top_user_data = cfg->user_data;
/* Enable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg |= TIMER0_CHANNEL(3);
sys_write32(reg, PIT_INTE(dev));
}
if (cfg->flags & COUNTER_TOP_CFG_DONT_RESET) {
/* Don't reset counter */
reset_counter = 0;
ticks = get_current_tick(dev, 3);
if (ticks >= cfg->ticks) {
err = -ETIME;
if (cfg->flags & COUNTER_TOP_CFG_RESET_WHEN_LATE) {
/* Reset counter if current is late */
reset_counter = 1;
}
}
}
/* Set cycle - 1 to reload register */
reg = cfg->ticks * config->divider;
sys_write32((reg - 1), PIT_CH_RELD(dev, 3));
if (reset_counter) {
/* Disable channel */
reg = sys_read32(PIT_CHEN(dev));
reg &= ~TIMER0_CHANNEL(3);
sys_write32(reg, PIT_CHEN(dev));
/* Clear interrupt status */
sys_write32(TIMER0_CHANNEL(3), PIT_ISTA(dev));
/* Enable channel interrupt */
reg = sys_read32(PIT_INTE(dev));
reg |= TIMER0_CHANNEL(3);
sys_write32(reg, PIT_INTE(dev));
/* Enable channel */
reg = sys_read32(PIT_CHEN(dev));
reg |= TIMER0_CHANNEL(3);
sys_write32(reg, PIT_CHEN(dev));
}
k_spin_unlock(&data->lock, key);
return err;
}
static uint32_t atcpit100_get_pending_int(const struct device *dev)
{
uint32_t reg = sys_read32(PIT_ISTA(dev));
reg &= (TIMER0_CHANNEL(0) | TIMER0_CHANNEL(1) |
TIMER0_CHANNEL(2) | TIMER0_CHANNEL(3));
return !(!reg);
}
static uint32_t atcpit100_get_top_value(const struct device *dev)
{
const struct atcpit100_config *config = dev->config;
uint32_t top = sys_read32(PIT_CH_RELD(dev, 3)) + 1;
return (top / config->divider);
}
static uint32_t atcpit100_get_guard_period(const struct device *dev,
uint32_t flags)
{
struct atcpit100_data *data = dev->data;
return data->guard_period;
}
static int atcpit100_set_guard_period(const struct device *dev,
uint32_t ticks, uint32_t flags)
{
const struct atcpit100_config *config = dev->config;
struct atcpit100_data *data = dev->data;
uint32_t top = sys_read32(PIT_CH_RELD(dev, 3)) + 1;
if ((ticks * config->divider) > top) {
return -EINVAL;
}
data->guard_period = ticks;
return 0;
}
static const struct counter_driver_api atcpit100_driver_api = {
.start = atcpit100_start,
.stop = atcpit100_stop,
.get_value = atcpit100_get_value,
.set_alarm = atcpit100_set_alarm,
.cancel_alarm = atcpit100_cancel_alarm,
.set_top_value = atcpit100_set_top_value,
.get_pending_int = atcpit100_get_pending_int,
.get_top_value = atcpit100_get_top_value,
.get_guard_period = atcpit100_get_guard_period,
.set_guard_period = atcpit100_set_guard_period,
};
#define COUNTER_ATCPIT100_INIT(n) \
static void counter_atcpit100_cfg_##n(void); \
static struct atcpit100_data atcpit100_data_##n; \
\
static const struct atcpit100_config atcpit100_config_##n = { \
.info = { \
.max_top_value = \
(UINT32_MAX/DT_INST_PROP(n, prescaler)),\
.freq = (DT_INST_PROP(n, clock_frequency) / \
DT_INST_PROP(n, prescaler)), \
.flags = COUNTER_CONFIG_INFO_COUNT_UP, \
.channels = CH_NUM_PER_COUNTER, \
}, \
.base = DT_INST_REG_ADDR(n), \
.divider = DT_INST_PROP(n, prescaler), \
.irq_num = DT_INST_IRQN(n), \
.cfg_func = counter_atcpit100_cfg_##n, \
}; \
\
DEVICE_DT_INST_DEFINE(n, \
counter_atcpit100_init, \
NULL, \
&atcpit100_data_##n, \
&atcpit100_config_##n, \
POST_KERNEL, \
CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \
&atcpit100_driver_api); \
\
static void counter_atcpit100_cfg_##n(void) \
{ \
IRQ_CONNECT(DT_INST_IRQN(n), \
DT_INST_IRQ(n, priority), \
atcpit100_irq_handler, \
DEVICE_DT_INST_GET(n), \
0); \
}
DT_INST_FOREACH_STATUS_OKAY(COUNTER_ATCPIT100_INIT)