2017-01-26 15:51:33 +01:00
|
|
|
/*
|
2018-10-23 18:08:58 +02:00
|
|
|
* Copyright (c) 2018 Intel Corporation
|
|
|
|
|
*
|
2017-01-26 15:51:33 +01:00
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
|
|
|
*/
|
2023-08-28 13:15:43 +02:00
|
|
|
#include <zephyr/init.h>
|
2022-05-06 10:25:46 +02:00
|
|
|
#include <zephyr/drivers/timer/system_timer.h>
|
|
|
|
|
#include <zephyr/sys_clock.h>
|
|
|
|
|
#include <zephyr/spinlock.h>
|
2022-10-17 10:24:11 +02:00
|
|
|
#include <zephyr/irq.h>
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
#define TIMER_IRQ UTIL_CAT(XCHAL_TIMER, \
|
|
|
|
|
UTIL_CAT(CONFIG_XTENSA_TIMER_ID, _INTERRUPT))
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2019-04-23 15:08:00 +02:00
|
|
|
#define CYC_PER_TICK (sys_clock_hw_cycles_per_sec() \
|
2018-10-23 18:08:58 +02:00
|
|
|
/ CONFIG_SYS_CLOCK_TICKS_PER_SEC)
|
2019-11-26 20:27:19 +01:00
|
|
|
#define MAX_CYC 0xffffffffu
|
|
|
|
|
#define MAX_TICKS ((MAX_CYC - CYC_PER_TICK) / CYC_PER_TICK)
|
2018-10-23 18:08:58 +02:00
|
|
|
#define MIN_DELAY 1000
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
static struct k_spinlock lock;
|
|
|
|
|
static unsigned int last_count;
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2022-06-28 23:58:40 +02:00
|
|
|
#if defined(CONFIG_TEST)
|
|
|
|
|
const int32_t z_sys_timer_irq_for_test = UTIL_CAT(XCHAL_TIMER,
|
|
|
|
|
UTIL_CAT(CONFIG_XTENSA_TIMER_ID, _INTERRUPT));
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-05-27 18:26:57 +02:00
|
|
|
static void set_ccompare(uint32_t val)
|
2017-10-27 18:08:42 +02:00
|
|
|
{
|
2018-10-23 18:08:58 +02:00
|
|
|
__asm__ volatile ("wsr.CCOMPARE" STRINGIFY(CONFIG_XTENSA_TIMER_ID) " %0"
|
|
|
|
|
:: "r"(val));
|
2017-10-27 18:08:42 +02:00
|
|
|
}
|
|
|
|
|
|
2020-05-27 18:26:57 +02:00
|
|
|
static uint32_t ccount(void)
|
2017-10-27 18:08:42 +02:00
|
|
|
{
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t val;
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
__asm__ volatile ("rsr.CCOUNT %0" : "=r"(val));
|
|
|
|
|
return val;
|
2017-10-27 18:08:42 +02:00
|
|
|
}
|
|
|
|
|
|
isr: Normalize usage of device instance through ISR
The goal of this patch is to replace the 'void *' parameter by 'struct
device *' if they use such variable or just 'const void *' on all
relevant ISRs
This will avoid not-so-nice const qualifier tweaks when device instances
will be constant.
Note that only the ISR passed to IRQ_CONNECT are of interest here.
In order to do so, the script fix_isr.py below is necessary:
from pathlib import Path
import subprocess
import pickle
import mmap
import sys
import re
import os
cocci_template = """
@r_fix_isr_0
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
...
(
const struct device *D = (const struct device *)P;
|
const struct device *D = P;
)
...
}
@r_fix_isr_1
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
...
const struct device *D;
...
(
D = (const struct device *)P;
|
D = P;
)
...
}
@r_fix_isr_2
@
type ret_type;
identifier A;
@@
-ret_type <!fn!>(void *A)
+ret_type <!fn!>(const void *A)
{
...
}
@r_fix_isr_3
@
const struct device *D;
@@
-<!fn!>((void *)D);
+<!fn!>(D);
@r_fix_isr_4
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
...
(
-const struct device *D = (const struct device *)P;
|
-const struct device *D = P;
)
...
}
@r_fix_isr_5
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
...
-const struct device *D;
...
(
-D = (const struct device *)P;
|
-D = P;
)
...
}
"""
def find_isr(fn):
db = []
data = None
start = 0
try:
with open(fn, 'r+') as f:
data = str(mmap.mmap(f.fileno(), 0).read())
except Exception as e:
return db
while True:
isr = ""
irq = data.find('IRQ_CONNECT', start)
while irq > -1:
p = 1
arg = 1
p_o = data.find('(', irq)
if p_o < 0:
irq = -1
break;
pos = p_o + 1
while p > 0:
if data[pos] == ')':
p -= 1
elif data[pos] == '(':
p += 1
elif data[pos] == ',' and p == 1:
arg += 1
if arg == 3:
isr += data[pos]
pos += 1
isr = isr.strip(',\\n\\t ')
if isr not in db and len(isr) > 0:
db.append(isr)
start = pos
break
if irq < 0:
break
return db
def patch_isr(fn, isr_list):
if len(isr_list) <= 0:
return
for isr in isr_list:
tmplt = cocci_template.replace('<!fn!>', isr)
with open('/tmp/isr_fix.cocci', 'w') as f:
f.write(tmplt)
cmd = ['spatch', '--sp-file', '/tmp/isr_fix.cocci', '--in-place', fn]
subprocess.run(cmd)
def process_files(path):
if path.is_file() and path.suffix in ['.h', '.c']:
p = str(path.parent) + '/' + path.name
isr_list = find_isr(p)
patch_isr(p, isr_list)
elif path.is_dir():
for p in path.iterdir():
process_files(p)
if len(sys.argv) < 2:
print("You need to provide a dir/file path")
sys.exit(1)
process_files(Path(sys.argv[1]))
And is run: ./fix_isr.py <zephyr root directory>
Finally, some files needed manual fixes such.
Fixes #27399
Signed-off-by: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
2020-06-17 14:58:56 +02:00
|
|
|
static void ccompare_isr(const void *arg)
|
2017-10-27 18:08:42 +02:00
|
|
|
{
|
2018-10-23 18:08:58 +02:00
|
|
|
ARG_UNUSED(arg);
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t curr = ccount();
|
|
|
|
|
uint32_t dticks = (curr - last_count) / CYC_PER_TICK;
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
last_count += dticks * CYC_PER_TICK;
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2020-05-12 04:32:40 +02:00
|
|
|
if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t next = last_count + CYC_PER_TICK;
|
2017-10-27 18:08:42 +02:00
|
|
|
|
2020-05-27 18:26:57 +02:00
|
|
|
if ((int32_t)(next - curr) < MIN_DELAY) {
|
2018-10-23 18:08:58 +02:00
|
|
|
next += CYC_PER_TICK;
|
|
|
|
|
}
|
|
|
|
|
set_ccompare(next);
|
2017-10-27 18:08:42 +02:00
|
|
|
}
|
|
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
k_spin_unlock(&lock, key);
|
2021-02-25 21:33:15 +01:00
|
|
|
sys_clock_announce(IS_ENABLED(CONFIG_TICKLESS_KERNEL) ? dticks : 1);
|
2017-10-27 18:08:42 +02:00
|
|
|
}
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2021-02-25 21:33:15 +01:00
|
|
|
void sys_clock_set_timeout(int32_t ticks, bool idle)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 18:08:58 +02:00
|
|
|
ARG_UNUSED(idle);
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2020-05-12 04:32:40 +02:00
|
|
|
#if defined(CONFIG_TICKLESS_KERNEL)
|
kernel/timeout: Make timeout arguments an opaque type
Add a k_timeout_t type, and use it everywhere that kernel API
functions were accepting a millisecond timeout argument. Instead of
forcing milliseconds everywhere (which are often not integrally
representable as system ticks), do the conversion to ticks at the
point where the timeout is created. This avoids an extra unit
conversion in some application code, and allows us to express the
timeout in units other than milliseconds to achieve greater precision.
The existing K_MSEC() et. al. macros now return initializers for a
k_timeout_t.
The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t
values, which means they cannot be operated on as integers.
Applications which have their own APIs that need to inspect these
vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to
test for equality.
Timer drivers, which receive an integer tick count in ther
z_clock_set_timeout() functions, now use the integer-valued
K_TICKS_FOREVER constant instead of K_FOREVER.
For the initial release, to preserve source compatibility, a
CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the
k_timeout_t will remain a compatible 32 bit value that will work with
any legacy Zephyr application.
Some subsystems present timeout (or timeout-like) values to their own
users as APIs that would re-use the kernel's own constants and
conventions. These will require some minor design work to adapt to
the new scheme (in most cases just using k_timeout_t directly in their
own API), and they have not been changed in this patch, instead
selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems
include: CAN Bus, the Microbit display driver, I2S, LoRa modem
drivers, the UART Async API, Video hardware drivers, the console
subsystem, and the network buffer abstraction.
k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant
provided that works identically to the original API.
Most of the changes here are just type/configuration management and
documentation, but there are logic changes in mempool, where a loop
that used a timeout numerically has been reworked using a new
z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was
enabled) a similar loop was needlessly used to try to retry the
k_poll() call after a spurious failure. But k_poll() does not fail
spuriously, so the loop was removed.
Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-06 00:18:14 +01:00
|
|
|
ticks = ticks == K_TICKS_FOREVER ? MAX_TICKS : ticks;
|
2020-10-27 12:27:25 +01:00
|
|
|
ticks = CLAMP(ticks - 1, 0, (int32_t)MAX_TICKS);
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t curr = ccount(), cyc, adj;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
/* Round up to next tick boundary */
|
2019-11-26 20:27:19 +01:00
|
|
|
cyc = ticks * CYC_PER_TICK;
|
|
|
|
|
adj = (curr - last_count) + (CYC_PER_TICK - 1);
|
|
|
|
|
if (cyc <= MAX_CYC - adj) {
|
|
|
|
|
cyc += adj;
|
|
|
|
|
} else {
|
|
|
|
|
cyc = MAX_CYC;
|
|
|
|
|
}
|
2018-10-23 18:08:58 +02:00
|
|
|
cyc = (cyc / CYC_PER_TICK) * CYC_PER_TICK;
|
|
|
|
|
cyc += last_count;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
if ((cyc - curr) < MIN_DELAY) {
|
|
|
|
|
cyc += CYC_PER_TICK;
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
2018-11-02 21:24:28 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
set_ccompare(cyc);
|
|
|
|
|
k_spin_unlock(&lock, key);
|
2017-12-14 22:21:12 +01:00
|
|
|
#endif
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
|
|
|
|
|
2021-02-25 21:33:15 +01:00
|
|
|
uint32_t sys_clock_elapsed(void)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 18:08:58 +02:00
|
|
|
if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
|
|
|
|
|
return 0;
|
2017-10-27 18:08:42 +02:00
|
|
|
}
|
2018-07-23 10:19:26 +02:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
k_spinlock_key_t key = k_spin_lock(&lock);
|
2020-05-27 18:26:57 +02:00
|
|
|
uint32_t ret = (ccount() - last_count) / CYC_PER_TICK;
|
2017-01-26 15:51:33 +01:00
|
|
|
|
2018-10-23 18:08:58 +02:00
|
|
|
k_spin_unlock(&lock, key);
|
|
|
|
|
return ret;
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
|
|
|
|
|
2021-03-12 18:46:52 +01:00
|
|
|
uint32_t sys_clock_cycle_get_32(void)
|
2017-01-26 15:51:33 +01:00
|
|
|
{
|
2018-10-23 18:08:58 +02:00
|
|
|
return ccount();
|
2017-01-26 15:51:33 +01:00
|
|
|
}
|
2019-01-28 18:12:13 +01:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
void smp_timer_init(void)
|
|
|
|
|
{
|
|
|
|
|
set_ccompare(ccount() + CYC_PER_TICK);
|
|
|
|
|
irq_enable(TIMER_IRQ);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2021-11-04 12:51:39 +01:00
|
|
|
|
init: remove the need for a dummy device pointer in SYS_INIT functions
The init infrastructure, found in `init.h`, is currently used by:
- `SYS_INIT`: to call functions before `main`
- `DEVICE_*`: to initialize devices
They are all sorted according to an initialization level + a priority.
`SYS_INIT` calls are really orthogonal to devices, however, the required
function signature requires a `const struct device *dev` as a first
argument. The only reason for that is because the same init machinery is
used by devices, so we have something like:
```c
struct init_entry {
int (*init)(const struct device *dev);
/* only set by DEVICE_*, otherwise NULL */
const struct device *dev;
}
```
As a result, we end up with such weird/ugly pattern:
```c
static int my_init(const struct device *dev)
{
/* always NULL! add ARG_UNUSED to avoid compiler warning */
ARG_UNUSED(dev);
...
}
```
This is really a result of poor internals isolation. This patch proposes
a to make init entries more flexible so that they can accept sytem
initialization calls like this:
```c
static int my_init(void)
{
...
}
```
This is achieved using a union:
```c
union init_function {
/* for SYS_INIT, used when init_entry.dev == NULL */
int (*sys)(void);
/* for DEVICE*, used when init_entry.dev != NULL */
int (*dev)(const struct device *dev);
};
struct init_entry {
/* stores init function (either for SYS_INIT or DEVICE*)
union init_function init_fn;
/* stores device pointer for DEVICE*, NULL for SYS_INIT. Allows
* to know which union entry to call.
*/
const struct device *dev;
}
```
This solution **does not increase ROM usage**, and allows to offer clean
public APIs for both SYS_INIT and DEVICE*. Note that however, init
machinery keeps a coupling with devices.
**NOTE**: This is a breaking change! All `SYS_INIT` functions will need
to be converted to the new signature. See the script offered in the
following commit.
Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
init: convert SYS_INIT functions to the new signature
Conversion scripted using scripts/utils/migrate_sys_init.py.
Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
manifest: update projects for SYS_INIT changes
Update modules with updated SYS_INIT calls:
- hal_ti
- lvgl
- sof
- TraceRecorderSource
Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
tests: devicetree: devices: adjust test
Adjust test according to the recently introduced SYS_INIT
infrastructure.
Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
tests: kernel: threads: adjust SYS_INIT call
Adjust to the new signature: int (*init_fn)(void);
Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
2022-10-19 09:33:44 +02:00
|
|
|
static int sys_clock_driver_init(void)
|
2021-11-04 12:51:39 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
IRQ_CONNECT(TIMER_IRQ, 0, ccompare_isr, 0, 0);
|
|
|
|
|
set_ccompare(ccount() + CYC_PER_TICK);
|
|
|
|
|
irq_enable(TIMER_IRQ);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SYS_INIT(sys_clock_driver_init, PRE_KERNEL_2,
|
|
|
|
|
CONFIG_SYSTEM_CLOCK_INIT_PRIORITY);
|
