patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 7 Packages Projects Releases Wiki Activity

drivers: counter: Add user_data to alarm callback

Browse source 
Modify alarm callback to return user_data and channel_id.
Set_alarm and disable_alarm updated accordingly. Renamed
counter_*_ch_alarm to counter_*_channel_alarm. Updated test
and nrf implementations.

Updated doxygen comments.

Signed-off-by: Krzysztof Chruscinski <krzysztof.chruscinski@nordicsemi.no>
This commit is contained in:
Krzysztof Chruscinski 2018-11-21 10:40:08 +01:00 committed by Anas Nashif
parent 5bfe8612a2
commit b745355315
4 changed files with 134 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
drivers/counter/counter_nrfx_rtc.c
View file

@ -28,9 +28,14 @@ struct counter_nrfx_data {
u32_t wrap;
};
struct counter_nrfx_ch_data {
counter_alarm_callback_t callback;
void *user_data;
};
struct counter_nrfx_config {
struct counter_config_info info;
const struct counter_alarm_cfg **alarm_cfgs;
struct counter_nrfx_ch_data *ch_data;
nrfx_rtc_t rtc;
LOG_INSTANCE_PTR_DECLARE(log);
@ -67,7 +72,7 @@ static u32_t counter_nrfx_read(struct device *dev)
return nrfx_rtc_counter_get(&get_nrfx_config(dev)->rtc);
}
static int counter_nrfx_set_alarm(struct device *dev,
static int counter_nrfx_set_alarm(struct device *dev, u8_t chan_id,
const struct counter_alarm_cfg *alarm_cfg)
{
const struct counter_nrfx_config *nrfx_config = get_nrfx_config(dev);
@ -78,7 +83,7 @@ static int counter_nrfx_set_alarm(struct device *dev,
return -EINVAL;
}
if (nrfx_config->alarm_cfgs[alarm_cfg->channel_id]) {
if (nrfx_config->ch_data[chan_id].callback) {
return -EBUSY;
}
@ -86,9 +91,10 @@ static int counter_nrfx_set_alarm(struct device *dev,
0 : nrfx_rtc_counter_get(rtc));
cc_val = (cc_val > get_dev_data(dev)->wrap) ?
(cc_val - get_dev_data(dev)->wrap) : cc_val;
nrfx_config->alarm_cfgs[alarm_cfg->channel_id] = alarm_cfg;
nrfx_config->ch_data[chan_id].callback = alarm_cfg->callback;
nrfx_config->ch_data[chan_id].user_data = alarm_cfg->user_data;
nrfx_rtc_cc_set(rtc, ID_TO_CC(alarm_cfg->channel_id), cc_val, true);
nrfx_rtc_cc_set(rtc, ID_TO_CC(chan_id), cc_val, true);
return 0;
}
@ -98,13 +104,12 @@ static void _disable(struct device *dev, u8_t id)
const struct counter_nrfx_config *config = get_nrfx_config(dev);
nrfx_rtc_cc_disable(&config->rtc, ID_TO_CC(id));
config->alarm_cfgs[id] = NULL;
config->ch_data[id].callback = NULL;
}
static int counter_nrfx_disable_alarm(struct device *dev,
const struct counter_alarm_cfg *alarm_cfg)
static int counter_nrfx_disable_alarm(struct device *dev, u8_t chan_id)
{
_disable(dev, alarm_cfg->channel_id);
_disable(dev, chan_id);
return 0;
}
@ -121,7 +126,7 @@ static int counter_nrfx_set_wrap(struct device *dev, u32_t ticks,
/* Overflow can be changed only when all alarms are
* disables.
*/
if (nrfx_config->alarm_cfgs[i]) {
if (nrfx_config->ch_data[i].callback) {
return -EBUSY;
}
}
@ -145,13 +150,17 @@ static u32_t counter_nrfx_get_pending_int(struct device *dev)
static void alarm_event_handler(struct device *dev, u32_t id)
{
const struct counter_nrfx_config *config = get_nrfx_config(dev);
const struct counter_alarm_cfg *alarm_cfg = config->alarm_cfgs[id];
counter_alarm_callback_t clbk = config->ch_data[id].callback;
u32_t cc_val;
if (!clbk) {
return;
}
cc_val = nrf_rtc_cc_get(config->rtc.p_reg, ID_TO_CC(id));
_disable(dev, id);
alarm_cfg->handler(dev, alarm_cfg, cc_val);
clbk(dev, id, cc_val, config->ch_data[id].user_data);
}
static void event_handler(nrfx_rtc_int_type_t int_type, void *p_context)
@ -244,8 +253,8 @@ static const struct counter_driver_api counter_nrfx_driver_api = {
return init_rtc(dev, &config, rtc_##idx##_handler); \
} \
static struct counter_nrfx_data counter_##idx##_data; \
static const struct counter_alarm_cfg \
*counter##idx##_alarm_cfgs[CC_TO_ID(RTC##idx##_CC_NUM)]; \
static struct counter_nrfx_ch_data \
counter##idx##_ch_data[CC_TO_ID(RTC##idx##_CC_NUM)]; \
LOG_INSTANCE_REGISTER(LOG_MODULE_NAME, idx, CONFIG_COUNTER_LOG_LEVEL); \
static const struct counter_nrfx_config nrfx_counter_##idx##_config = {\
.info = { \
@ -255,7 +264,7 @@ static const struct counter_driver_api counter_nrfx_driver_api = {
.count_up = true, \
.channels = CC_TO_ID(RTC##idx##_CC_NUM) \
}, \
.alarm_cfgs = counter##idx##_alarm_cfgs, \
.ch_data = counter##idx##_ch_data, \
.rtc = NRFX_RTC_INSTANCE(idx), \
LOG_INSTANCE_PTR_INIT(log, LOG_MODULE_NAME, idx) \
}; \

44
drivers/counter/counter_nrfx_timer.c
View file

@ -30,9 +30,14 @@ struct counter_nrfx_data {
void *wrap_user_data;
};
struct counter_nrfx_ch_data {
counter_alarm_callback_t callback;
void *user_data;
};
struct counter_nrfx_config {
struct counter_config_info info;
const struct counter_alarm_cfg **alarm_cfgs;
struct counter_nrfx_ch_data *ch_data;
nrfx_timer_t timer;
LOG_INSTANCE_PTR_DECLARE(log);
@ -70,7 +75,7 @@ static u32_t counter_nrfx_read(struct device *dev)
COUNTER_READ_CC);
}
static int counter_nrfx_set_alarm(struct device *dev,
static int counter_nrfx_set_alarm(struct device *dev, u8_t chan_id,
const struct counter_alarm_cfg *alarm_cfg)
{
const struct counter_nrfx_config *nrfx_config = get_nrfx_config(dev);
@ -81,16 +86,16 @@ static int counter_nrfx_set_alarm(struct device *dev,
return -EINVAL;
}
if (nrfx_config->alarm_cfgs[alarm_cfg->channel_id]) {
if (nrfx_config->ch_data[chan_id].callback) {
return -EBUSY;
}
cc_val = alarm_cfg->ticks + (alarm_cfg->absolute ?
0 : nrfx_timer_capture(timer, COUNTER_READ_CC));
nrfx_config->alarm_cfgs[alarm_cfg->channel_id] = alarm_cfg;
nrfx_config->ch_data[chan_id].callback = alarm_cfg->callback;
nrfx_config->ch_data[chan_id].user_data = alarm_cfg->user_data;
nrfx_timer_compare(timer, ID_TO_CC(alarm_cfg->channel_id),
cc_val, true);
nrfx_timer_compare(timer, ID_TO_CC(chan_id), cc_val, true);
return 0;
}
@ -100,17 +105,17 @@ static void _disable(struct device *dev, u8_t id)
const struct counter_nrfx_config *config = get_nrfx_config(dev);
nrfx_timer_compare_int_disable(&config->timer, ID_TO_CC(id));
config->alarm_cfgs[id] = NULL;
config->ch_data[id].callback = NULL;
}
static int counter_nrfx_disable_alarm(struct device *dev,
const struct counter_alarm_cfg *alarm_cfg)
static int counter_nrfx_disable_alarm(struct device *dev,u8_t chan_id)
{
_disable(dev, alarm_cfg->channel_id);
_disable(dev, chan_id);
return 0;
}
static int counter_nrfx_set_wrap(struct device *dev, u32_t ticks,
counter_wrap_callback_t callback,
void *user_data)
@ -123,7 +128,7 @@ static int counter_nrfx_set_wrap(struct device *dev, u32_t ticks,
/* Overflow can be changed only when all alarms are
* disables.
*/
if (nrfx_config->alarm_cfgs[i]) {
if (nrfx_config->ch_data[i].callback) {
return -EBUSY;
}
}
@ -147,18 +152,17 @@ static u32_t counter_nrfx_get_pending_int(struct device *dev)
static void alarm_event_handler(struct device *dev, u32_t id)
{
const nrfx_timer_t *timer = &get_nrfx_config(dev)->timer;
const struct counter_alarm_cfg *alarm_cfg =
get_nrfx_config(dev)->alarm_cfgs[id];
const struct counter_nrfx_config *config = get_nrfx_config(dev);
counter_alarm_callback_t clbk = config->ch_data[id].callback;
u32_t cc_val;
if (!alarm_cfg->handler) {
if (!clbk) {
return;
}
cc_val = nrfx_timer_capture_get(timer, ID_TO_CC(id));
cc_val = nrfx_timer_capture_get(&config->timer, ID_TO_CC(id));
_disable(dev, id);
alarm_cfg->handler(dev, alarm_cfg, cc_val);
clbk(dev, id, cc_val, config->ch_data[id].user_data);
}
static void event_handler(nrf_timer_event_t event_type, void *p_context)
@ -234,8 +238,8 @@ static const struct counter_driver_api counter_nrfx_driver_api = {
return init_timer(dev, &config); \
} \
static struct counter_nrfx_data counter_##idx##_data; \
static const struct counter_alarm_cfg \
*counter##idx##_alarm_cfgs[CC_TO_ID(TIMER##idx##_CC_NUM)]; \
static struct counter_nrfx_ch_data \
counter##idx##_ch_data[CC_TO_ID(TIMER##idx##_CC_NUM)]; \
LOG_INSTANCE_REGISTER(LOG_MODULE_NAME, idx, CONFIG_COUNTER_LOG_LEVEL); \
static const struct counter_nrfx_config nrfx_counter_##idx##_config = {\
.info = { \
@ -246,7 +250,7 @@ static const struct counter_driver_api counter_nrfx_driver_api = {
.count_up = true, \
.channels = CC_TO_ID(TIMER##idx##_CC_NUM), \
}, \
.alarm_cfgs = counter##idx##_alarm_cfgs, \
.ch_data = counter##idx##_ch_data, \
.timer = NRFX_TIMER_INSTANCE(idx), \
LOG_INSTANCE_PTR_INIT(log, LOG_MODULE_NAME, idx) \
}; \

114
include/counter.h
View file

@ -29,45 +29,37 @@
extern "C" {
#endif
struct counter_alarm_cfg;
/** @brief Alarm callback
*
* @param dev Pointer to the device structure for the driver instance.
* @param cfg Original structure owning this handler.
* @param ticks Counter value that triggered the callback.
* @param dev Pointer to the device structure for the driver instance.
* @param chan_id Channel ID.
* @param ticks Counter value that triggered the callback.
* @param user_data User data.
*/
typedef void (*counter_alarm_callback_t)(struct device *dev,
const struct counter_alarm_cfg *cfg,
u32_t ticks);
u8_t chan_id, u32_t ticks,
void *user_data);
/** @brief Alarm callback structure.
*
* Used to set an alarm.
* Beware such structure should not be allocated on stack.
* @param callback Callback called on alarm (cannot be NULL).
* @param ticks Ticks that triggers the alarm. In case of absolute flag is set,
* maximal value that can be set equals wrap value
* (counter_get_wrap). Otherwise counter_get_max_relative_alarm()
* returns maximal value that can be set. If counter is clock
* driven then ticks can be converted to microseconds (see @ref
* counter_ticks_to_us). Alternatively, counter implementation may
* count asynchronous events.
* @param user_data User data returned in callback.
* @param absolute Ticks relation to counter value. If true ticks are treated as
* absolute value, else it is relative to the counter reading
* performed during the call.
*/
struct counter_alarm_cfg {
counter_alarm_callback_t handler; /*!< handler called on alarm
* (cannot be NULL).
*/
u32_t ticks; /*!< In case of absolute flag is set, maximal value that
* can be set equals wrap value (counter_get_wrap).
* Otherwise counter_get_max_relative_alarm() returns
* maximal value that can be set. If counter is clock
* driven then ticks can be converted to microseconds
* (see @ref counter_ticks_to_us). Alternatively,
* counter implementation may count asynchronous events.
*/
u8_t channel_id; /*!< Channel ID. Number of channels is driver
* dependent.
*/
bool absolute; /*!< If true ticks are treated as absolute value, else
* it is relative to the counter reading performed
* during the call.
*/
counter_alarm_callback_t callback;
u32_t ticks;
void *user_data;
bool absolute;
};
/** @brief Wrap callback
@ -77,32 +69,29 @@ struct counter_alarm_cfg {
*/
typedef void (*counter_wrap_callback_t)(struct device *dev, void *user_data);
/** @brief Structure with generic counter features. */
/** @brief Structure with generic counter features.
*
* @param max_wrap Maximal (default) wrap value on which counter is reset
* (cleared or reloaded).
* @param freq Frequency of the source clock if synchronous events are counted.
* @param count_up Flag indicating direction of the counter. If true counter is
* counting up else counting down.
* @param channels Number of channels that can be used for setting alarm,
* see @ref counter_set_alarm.
*/
struct counter_config_info {
u32_t max_wrap; /*!< Maximal (default) wrap value on which counter is
* reset (cleared or reloaded).
*/
u32_t freq; /*!< Frequency of the source clock if synchronous events
* are counted.
*/
bool count_up; /*!< Flag indicating direction of the counter. If true
* counter is counting up else counting down.
*/
u8_t channels; /*!< Number of channels that can be used for setting
* alarm, see @ref counter_set_alarm.
*/
u32_t max_wrap;
u32_t freq;
bool count_up;
u8_t channels;
};
typedef int (*counter_api_start)(struct device *dev);
typedef int (*counter_api_stop)(struct device *dev);
typedef u32_t (*counter_api_read)(struct device *dev);
typedef int (*counter_api_set_alarm)(struct device *dev,
const struct counter_alarm_cfg *alarm_cfg);
typedef int (*counter_api_disable_alarm)(struct device *dev,
typedef int (*counter_api_set_alarm)(struct device *dev, u8_t chan_id,
const struct counter_alarm_cfg *alarm_cfg);
typedef int (*counter_api_disable_alarm)(struct device *dev, u8_t chan_id);
typedef int (*counter_api_set_wrap)(struct device *dev, u32_t ticks,
counter_wrap_callback_t callback,
void *user_data);
@ -133,7 +122,7 @@ struct counter_driver_api {
* @retval true if counter is counting up.
* @retval false if counter is counting down.
*/
static inline bool counter_count_up(const struct device *dev)
static inline bool counter_is_counting_up(const struct device *dev)
{
const struct counter_config_info *config = dev->config->config_info;
@ -273,6 +262,7 @@ static inline u32_t _impl_counter_read(struct device *dev)
* counter_get_max_relative_alarm.
*
* @param dev Pointer to the device structure for the driver instance.
* @param chan_id Channel ID.
* @param alarm_cfg Alarm configuration.
*
* @retval 0 If successful.
@ -280,39 +270,38 @@ static inline u32_t _impl_counter_read(struct device *dev)
* interrupts or requested channel).
* @retval -EINVAL if alarm settings are invalid.
*/
static inline int counter_set_ch_alarm(struct device *dev,
const struct counter_alarm_cfg *alarm_cfg)
static inline int counter_set_channel_alarm(struct device *dev, u8_t chan_id,
const struct counter_alarm_cfg *alarm_cfg)
{
const struct counter_driver_api *api = dev->driver_api;
if (alarm_cfg->channel_id >= counter_get_num_of_channels(dev)) {
if (chan_id >= counter_get_num_of_channels(dev)) {
return -ENOTSUP;
}
return api->set_alarm(dev, alarm_cfg);
return api->set_alarm(dev, chan_id, alarm_cfg);
}
/**
* @brief Disable an alarm on a channel.
*
* @param dev Pointer to the device structure for the driver instance.
* @param alarm_cfg Alarm configuration. It must be the same address as the
* one used for @ref counter_set_alarm.
* @param chan_id Channel ID.
*
* @retval 0 If successful.
* @retval -ENOTSUP if request is not supported or the counter was not started
* yet.
*/
static inline int counter_disable_ch_alarm(struct device *dev,
const struct counter_alarm_cfg *alarm_cfg)
static inline int counter_disable_channel_alarm(struct device *dev,
u8_t chan_id)
{
const struct counter_driver_api *api = dev->driver_api;
if (alarm_cfg->channel_id >= counter_get_num_of_channels(dev)) {
if (chan_id >= counter_get_num_of_channels(dev)) {
return -ENOTSUP;
}
return api->disable_alarm(dev, alarm_cfg);
return api->disable_alarm(dev, chan_id);
}
/**
@ -402,9 +391,12 @@ static inline u32_t _impl_counter_get_max_relative_alarm(struct device *dev)
return api->get_max_relative_alarm(dev);
}
/* Deprecated */
/* Deprecated counter callback. */
typedef void (*counter_callback_t)(struct device *dev, void *user_data);
/**
* @brief Deprecated function.
*/
__deprecated static inline int counter_set_alarm(struct device *dev,
counter_callback_t callback,
u32_t count, void *user_data)

68
tests/drivers/counter/counter_basic_api/src/test_counter.c
View file

@ -8,8 +8,8 @@
#include <ztest.h>
#include <kernel.h>
static volatile int wrap_cnt;
static volatile int alarm_cnt;
static volatile u32_t wrap_cnt;
static volatile u32_t alarm_cnt;
static void wrap_handler(struct device *dev, void *user_data);
@ -83,12 +83,11 @@ static void wrap_handler(struct device *dev, void *user_data)
wrap_cnt++;
}
#include <nrf_gpio.h>
void test_wrap_alarm_instance(const char *dev_name)
{
struct device *dev;
int err;
int cnt;
u32_t cnt;
u32_t ticks;
wrap_cnt = 0;
@ -120,11 +119,10 @@ void test_wrap_alarm(void)
test_all_instances(test_wrap_alarm_instance);
}
static void alarm_handler(struct device *dev,
const struct counter_alarm_cfg *cfg,
u32_t counter)
static void alarm_handler(struct device *dev, u8_t chan_id, u32_t counter,
void *user_data)
{
zassert_true(&alarm_cfg == cfg, "Unexpected callback\n");
zassert_true(&alarm_cfg == user_data, "Unexpected callback\n");
alarm_cnt++;
}
@ -137,10 +135,10 @@ void test_single_shot_alarm_instance(const char *dev_name)
dev = device_get_binding(dev_name);
ticks = counter_us_to_ticks(dev, WRAP_PERIOD_US);
alarm_cfg.channel_id = 0;
alarm_cfg.absolute = true;
alarm_cfg.ticks = ticks + 1;
alarm_cfg.handler = alarm_handler;
alarm_cfg.callback = alarm_handler;
alarm_cfg.user_data = &alarm_cfg;
alarm_cnt = 0;
@ -150,11 +148,11 @@ void test_single_shot_alarm_instance(const char *dev_name)
err = counter_set_wrap(dev, ticks, wrap_handler, exp_user_data);
zassert_equal(0, err, "Counter failed to set wrap\n");
err = counter_set_ch_alarm(dev, &alarm_cfg);
err = counter_set_channel_alarm(dev, 0, &alarm_cfg);
zassert_equal(-EINVAL, err, "Counter should return error because ticks exceeded the limit set alarm\n");
alarm_cfg.ticks = ticks - 100;
err = counter_set_ch_alarm(dev, &alarm_cfg);
err = counter_set_channel_alarm(dev, 0, &alarm_cfg);
zassert_equal(0, err, "Counter set alarm failed\n");
k_busy_wait(1.2*counter_ticks_to_us(dev, ticks));
@ -164,7 +162,7 @@ void test_single_shot_alarm_instance(const char *dev_name)
k_busy_wait(counter_ticks_to_us(dev, 2*ticks));
zassert_equal(1, alarm_cnt, "Expecting alarm callback\n");
err = counter_disable_ch_alarm(dev, &alarm_cfg);
err = counter_disable_channel_alarm(dev, 0);
zassert_equal(0, err, "Counter disabling alarm failed\n");
err = counter_set_wrap(dev, counter_get_max_wrap(dev), NULL, NULL);
@ -179,13 +177,12 @@ void test_single_shot_alarm(void)
test_all_instances(test_single_shot_alarm_instance);
}
static const struct counter_alarm_cfg *clbks[2];
static void *clbk_data[2];
static void alarm_handler2(struct device *dev,
const struct counter_alarm_cfg *cfg,
u32_t counter)
static void alarm_handler2(struct device *dev, u8_t chan_id, u32_t counter,
void *user_data)
{
clbks[alarm_cnt] = cfg;
clbk_data[alarm_cnt] = user_data;
alarm_cnt++;
}
@ -204,15 +201,15 @@ void test_multiple_alarms_instance(const char *dev_name)
dev = device_get_binding(dev_name);
ticks = counter_us_to_ticks(dev, WRAP_PERIOD_US);
alarm_cfg.channel_id = 0;
alarm_cfg.absolute = true;
alarm_cfg.ticks = counter_us_to_ticks(dev, 2000);
alarm_cfg.handler = alarm_handler2;
alarm_cfg.callback = alarm_handler2;
alarm_cfg.user_data = &alarm_cfg;
alarm_cfg2.channel_id = 1;
alarm_cfg2.absolute = false;
alarm_cfg2.ticks = counter_us_to_ticks(dev, 2000);
alarm_cfg2.handler = alarm_handler2;
alarm_cfg2.callback = alarm_handler2;
alarm_cfg2.user_data = &alarm_cfg2;
alarm_cnt = 0;
@ -222,24 +219,26 @@ void test_multiple_alarms_instance(const char *dev_name)
err = counter_set_wrap(dev, ticks, wrap_handler, exp_user_data);
zassert_equal(0, err, "Counter failed to set wrap\n");
k_busy_wait(1.2*counter_ticks_to_us(dev, alarm_cfg.ticks));
k_busy_wait(1.4*counter_ticks_to_us(dev, alarm_cfg.ticks));
err = counter_set_ch_alarm(dev, &alarm_cfg);
err = counter_set_channel_alarm(dev, 0, &alarm_cfg);
zassert_equal(0, err, "Counter set alarm failed\n");
err = counter_set_ch_alarm(dev, &alarm_cfg2);
err = counter_set_channel_alarm(dev, 1, &alarm_cfg2);
zassert_equal(0, err, "Counter set alarm failed\n");
k_busy_wait(1.2*counter_ticks_to_us(dev, 2*ticks));
zassert_equal(2, alarm_cnt, "Counter set alarm failed\n");
zassert_equal(&alarm_cfg2, clbks[0], "Expected different order or callbacks\n");
zassert_equal(&alarm_cfg, clbks[1], "Expected different order or callbacks\n");
zassert_equal(&alarm_cfg2, clbk_data[0],
"Expected different order or callbacks\n");
zassert_equal(&alarm_cfg, clbk_data[1],
"Expected different order or callbacks\n");
/* tear down */
err = counter_disable_ch_alarm(dev, &alarm_cfg);
err = counter_disable_channel_alarm(dev, 0);
zassert_equal(0, err, "Counter disabling alarm failed\n");
err = counter_disable_ch_alarm(dev, &alarm_cfg2);
err = counter_disable_channel_alarm(dev, 1);
zassert_equal(0, err, "Counter disabling alarm failed\n");
}
@ -262,17 +261,16 @@ void test_all_channels_instance(const char *str)
ticks = counter_us_to_ticks(dev, WRAP_PERIOD_US);
for (int i = 0; i < n; i++) {
alarm_cfgs[i].channel_id = i;
alarm_cfgs[i].absolute = false;
alarm_cfgs[i].ticks = ticks-100;
alarm_cfgs[i].handler = alarm_handler2;
alarm_cfgs[i].callback = alarm_handler2;
}
err = counter_start(dev);
zassert_equal(0, err, "Counter failed to start");
for (int i = 0; i < n; i++) {
err = counter_set_ch_alarm(dev, &alarm_cfgs[i]);
err = counter_set_channel_alarm(dev, i, &alarm_cfgs[i]);
if ((err == 0) && !limit_reached) {
nchan++;
} else if (err == -ENOTSUP) {
@ -283,12 +281,12 @@ void test_all_channels_instance(const char *str)
}
for (int i = 0; i < nchan; i++) {
err = counter_disable_ch_alarm(dev, &alarm_cfgs[i]);
err = counter_disable_channel_alarm(dev, i);
zassert_equal(0, err, "Unexpected error on disabling alarm");
}
for (int i = nchan; i < n; i++) {
err = counter_disable_ch_alarm(dev, &alarm_cfgs[i]);
err = counter_disable_channel_alarm(dev, i);
zassert_equal(-ENOTSUP, err, "Unexpected error on disabling alarm\n");
}
}